Главная страница Случайная страница
Разделы сайта
АвтомобилиАстрономияБиологияГеографияДом и садДругие языкиДругоеИнформатикаИсторияКультураЛитератураЛогикаМатематикаМедицинаМеталлургияМеханикаОбразованиеОхрана трудаПедагогикаПолитикаПравоПсихологияРелигияРиторикаСоциологияСпортСтроительствоТехнологияТуризмФизикаФилософияФинансыХимияЧерчениеЭкологияЭкономикаЭлектроника
Понятие об обработке исключений, создании собственных исключений.
|
|
Суть исключений в том, что функция или метод, обнаружив проблему, возбуждают исключения в надежде, что вызывавшая её функция решит проблему.
Механизм обработки исключений позволяет отделить код обработки ошибок от собственного кода алгоритма, делая программу более понятной.
Блок кода, который может вызвать ошибку, помещают в try { … }. Если при выполнении блока программист сразу предусматривает некоторую ошибку, он может использовать throw для того, чтобы передать управление коду из соответствующего блока в catch(…) { … }. Параметром блока catch будет служить определенный тип, при работе с которым произошла ошибка либо который передает throw. Блоков catch () может быть несколько, при этом располагать их необходимо в порядке, учитывая, что при ошибке соответствующий обработчик исключения будет отдавать приоритет тому catch, который стоит раньше в коде; это следует учитывать при расположении блоков catch, т.к. при поиске необходимого обработчика может произойти неявное преобразования типа. Последним устанавливается блок catch(…) с тремя точками, который обрабатывает любую ошибку независимо от её типа.
Иными словами, за одним try-блоком могут следовать несколько catch-блоков. Оператор catch, с указанным вместо типа исключения многоточием, перехватывает исключения любого типа и должен быть последним из операторов catch, следующих за try-блоком.
Пример программы:
…{
cout < < " num1 + num2 = " < < num1 + num2 < < endl;
cout < < " num1 / num2 = ";
try
{
if (num2 == 0) throw 123;
cout < < num1 / num2 < < endl;
}
catch (int i)
{
cout < < " Ошибка №" < < i < < " - на 0 делить нельзя!!!! " < < endl;
}
cout < < " num1 - num2 = " < < num1 - num2 < < endl;
cout < < " =================================" < < endl < < endl;
}…
14. Приведение типов: в стиле C, static_cast, dynamic_cast, const_cast, reinterpret_cast.
В языке C++ существует четыре разновидности приведения типа. Все четыре типа записываются в виде
xxx_cast < type_to> (expression_from)1. static_cast.
Синтаксис: TYPE static_cast< TYPE> (object);
static_cast преобразует выражения одного статического типа в объекты и значения другого статического типа. Поддерживается преобразование численных типов, указателей и ссылок по иерархии наследования как вверх, так и вниз. Проверка производится на уровне компиляции, так что в случае ошибки сообщение будет получено в момент сборки приложения или библиотеки.
2. dynamic_cast
Синтаксис: TYPE& dynamic_cast< TYPE& > (object); или TYPE* dynamic_cast< TYPE*> (object);
Используется для динамического приведения типов во время выполнения. В случае неправильного приведения типов для ссылок вызывается исключительная ситуация std:: bad_cast, а для указателей будет возвращен 0. Использует систему RTTI (Runtime Type Information). Безопасное приведение типов по иерархии наследования, в том числе для виртуального наследования.
3. const_cast.
Синтаксис: TYPE const_cast< TYPE> (object);
Пожалуй самое простое приведение типов. Снимает const, то есть константность. Это преобразование проверяется на уровне компиляции и в случае ошибки приведения типов будет выдано сообщение.
4. reinterpret_cast
Синтаксис: TYPE reinterpret_cast< TYPE> (object);
Приведение типов без проверки. reinterpret_cast — непосредственное указание компилятору. Применяется только в случае полной уверенности программиста в собственных действиях. Не снимает константность. Применяется для приведения указателя к указателю, указателя к целому и наоборот. 5. В стиле С Для явного приведения типов некоторой переменной перед ней следует указать в круглых скобках имя нового типа, например: int X; int Y = 200; char C = 30; X = (int)C * 10 + Y; 15. Перегрузка операторов – членов класса. За небольшими исключениями большинство операторов С++ могут быть перегружены, в результате чего они получат специальное значение по отношению к определенным классам. Например, класс, определяющий связанный список, может использовать оператор + для того, чтобы добавлять объект к списку. Другой класс может использовать оператор + совершенно иным способом. Когда оператор перегружен, ни одно из его исходных значений не теряет смысла. Просто для определенного класса объектов определен новый оператор. Поэтому перегрузка оператора + для того, чтобы обрабатывать связанный список, не изменяет его действия по отношению к целым числам.Общая форма записи функции-оператора для случая, когда она является членом класса, имеет вид:
тип имя_класса:: operator#(список_аргументов)
{
// действия, определенные применительно к классу
} Пример программы:
#include < iostream.h>
class three_d {
int x, y, z; // трехмерные координаты
public:
three_d operators+(three_d t);
three_d operator=(three_d t);
void show ();
void assign (int mx, int my, int mz);
};
// перегрузка +
three_d three_d:: operator+(three_d t)
{
three_d temp;
temp.x = x+t.x;
temp.у = y+t.y;
temp.z = z+t.z;
return temp;
}
// перегрузка =
three_d three_d:: operator=(three_d t)
{
x = t.x;
y = t.y;
z = t.z;
return *this;
}
// вывод координат X, Y, Z
void three_d:: show ()
{
cout < < x < < ", ";
cout < < у < < ", ";
cout < < z < < " \n";
}
// присвоение координат
void three_d:: assign (int mx, int my, int mz)
{
x = mx;
y = my;
z = mz;
}
int main()
{
three_d a, b, c;
a.assign (1, 2, 3);
b.assign (10, 10, 10);
a.show();
b.show();
с = a+b; // сложение а и b
c.show();
с = a+b+c; // сложение a, b и с
с.show();
с = b = a; // демонстрация множественного присваивания
с.show();
b.show ();
return 0;
}
|
|