4. Роль типа исключения в его обработке. Охранный блок, блок перехвата. Использование механизма обработки исключений. Примеры использования.

см. вопр. 3

В данном примере необходимо выделить три ключевых элемента. Во-

первых, вызов функции div() заключен внутрь блока, который начинается с

ключевого слова try. Этот блок указывает, что внутри него могут

происходить исключительные ситуации. По этой причине код, заключенный

внутри блока try, иногда называют охранным.

Далее за блоком try следует блок catch, называемый обычно

обработчиком исключительной ситуации. Если возникает исключительная

ситуация, выполнение программы переходит к этому catch-блоку. Хотя в

этом примере имеется один единственный обработчик, их в программах

может быть множество, и они способны обрабатывать множество различных

типов исключительных ситуаций.

Еще одним элементом процесса обработки исключительных ситуаций

является оператор throw (в данном случае он находится внутри функции

div()). Оператор throw сигнализирует об исключительном событии и

генерирует объект исключительной ситуации, который перехватывается

обработчиком catch. Этот процесс называется вызовом исключительной

ситуации. В рассматриваемом примере исключительная ситуация имеет

форму обычного целого числа, однако программы могут генерировать

практически любой тип исключительной ситуации.

Если в инструкции if(divisor==0) throw 1 значение 1 заменить на 1., то

при выполнении будет выдана ошибка об отсутствии соответствующего

обработчика catch (так как генерируется исключительная ситуация типа

double).

Когда тип исключения в блоке catch совпадает с типом

сгенерированного исключения, выполняется связанный с ним блок

catch. По завершении выполнения кода обработчика управление

переходит к оператору, следующему непосредственно после него.

Существует также абсолютный обработчик, который совместим с

любым типом исключительной ситуации. Для написания такого

обработчика надо вместо аргументов написать многоточие (эллипсис).

catch (...) {блок обработки исключения}

Использование абсолютного обработчика исключительных ситуаций

рассмотрим на примере программы, в которой происходит генерация

исключительной ситуации типа char*, но обработчик такого типа

отсутствует. В этом случае управление передается абсолютному

обработчику.

5. Использование объектов классов в качестве исключений. Одинаковые свойства и различия операторов throw и return. Примеры использования.

Выполнение оператора throw похоже на return, так как он завершает выполнение функции, однако вместо возврата управления вызывающей программе throw заставляет программу выполняться по текущей цепочке вызовов до тех пор, пока не будет найден соответствующего типа блок catch.

Иногда возникает положение, при котором необходимо обработать

исключительную ситуацию сначала на более низком уровне

вложенности блока try, а затем передать ее на более высокий уровень для

продолжения обработки. Для того чтобы сделать это, нужно

использовать throw без аргументов.

#include<iostream>

using namespace std;

void calculate(int i) {

try { if (i) throw "Error"; }

catch (const char* s) {

cout << s << "- выполняется первый обработчик" << endl;

throw;

}

}

int main() {

try { calculate(1); }

catch (const char* s) {

cout << s << "- выполняется второй обработчик"<< endl;

}

}

Исключительная ситуация может быть обработана обработчиком,

типом которого базовым для данного типа исключительной ситуации. Это

значит, что если, например, класс В – производный от класса А, то

обработчик типа класса А может обрабатывать исключительную ситуацию

класса В.

Рассмотрим особенности выбора соответствующего обработчика на

следующем примере. Пусть имеется класс С, являющийся производным от

классов А и В; показано, какими обработчиками может быть перехвачена

исключительная ситуация типа С и типа указателя на С.

#include<iostream>

using namespace std;

class A {};

class B {};

class C : public A, public B {};

void calculate(int i) {

if (i) throw C(); // тип объект класса С

else throw new C; // тип указатель класса С

}

int main() {

int i;

while (true) {

try {

cin >> i;

calculate(i);

}

catch (A) {

cout << "Обработчик типа \"объект класс A\"" << endl; }

catch (B&) {

cout << "Обработчик типа \"ссылка класс B\"" << endl; }

catch (C) {

cout << "Обработчик типа \"объект класс C\"" << endl; }

catch (C*) {

cout <<"Обработчик типа \"указатель класса C\""<< endl;}

catch (A*) {

cout <<"Обработчик типа \"указатель класса A\""<< endl;}

catch (void*) {

cout<< "Обработчик типа \"void*\""<<endl;}

}

}

В данном примере исключительная ситуация класса С может быть

направлена любому из обработчиков A, B& или C, поэтому выбирается

обработчик, стоящий первым в списке. Аналогично для исключительной

ситуации, имеющей тип указателя на объект класса С, выбирается первый

подходящий обработчик A* или C*. Эта ситуация также может быть

обработана так же обработчиками void*. Так как к типу void* может быть

приведен любой указатель, то обработчик этого типа будет перехватывать

любые исключительные ситуации типа указателя.

6. Спецификации исключений в С++11 (throw, noexcept). Примеры использования.

Спецификации исключений были добавлены в С++98, но в С++11 они объявлены устаревшими. Это значит, что спецификация исключений включена в стандарт, однако может быть изъята в будущем, поэтому в новом коде ее использовать не стоит.

Часть throw() со списком типов исключений или без него является спецификацией исключений. Она должна присутствовать как в прототипе, так и в определении функции.

Одна из основных причин появления спецификации исключений – необходимость уведомления о том, что может понадобиться блок try. Другая причина – разрешение компилятору на добавление кода, который во время выполнения будет проверять, нарушена ли спецификация исключений.

В С++11разрешена специальная спецификация, которая представлена ключевым словом noexcept. Она указывает, что функция не генерирует исключений. Знание о том, что функция не создает исключений, помогает компилятору оптимизировать код.

double div(double divisible, double divisor) throw();

double div(double divisible, double divisor) throw(){

if (divisor == 0) throw 1;

return divisible / divisor;

}

// или

double div(double divisible, double divisor) throw(invalid_argument);

double div(double divisible, double divisor) throw(invalid_argument){

if (divisor == 0) throw invalid_argument(“Division by zero”);

return divisible / divisor;

}

// throw (int, string)

void printData() noexcept;