Лекция 24.03.2014 г. 1 Исключения и обработка исключений (примеры программ)

перехват и обработку. Важно уяснить, что при генерации исключения сначала

происходит разрушение всех локальных объектов, а уже потом – переход к поиску подходящего обработчика

//Программа Ex005.cpp
#include
using namespace std;
class SomeClass {
public:
SomeClass() { cout << "start SomeClass()" << endl; }
~SomeClass() { cout << "start ~SomeClass()" << endl; }
};
void oz() {
SomeClass rb;
for(int i = 0; i < 3; i++) cout << "inside a function oz...\n";
throw 47;
}
int main() {
try { cout << "start main...\n”; oz();}
catch (int) {
cout << "inside catch(int)\n”;
}
}

класса перехватывает исключение производного класса (маскирует его)
//Программа Ex006.cpp
#include
using namespace

std;
class X {
public:
class Trouble {};
class Small : public Trouble {};
class Big : public Trouble {};
void f() { throw Big(); }
};
int main() {
X x;
try { x.f(); }
catch(X::Trouble&) { cout << "caught Trouble" << endl; }
catch(X::Small&) { cout << "caught Small Trouble" << endl; }
catch(X::Big&) { cout << "caught Big Trouble" << endl; }
}

правильном порядке: сначала – производные классы, а за ними –

базовый класс

//Программа Ex006.cpp
#include
using namespace std;
class X {
public:
class Trouble {};
class Small : public Trouble {};
class Big : public Trouble {};
void f() { throw Big(); }
};
int main() {
X x;
try { x.f(); }
catch(X::Small&) { cout << "caught Small Trouble" << endl; }
catch(X::Big&) { cout << "caught Big Trouble" << endl; }
catch(X::Trouble&) { cout << "caught Trouble" << endl; }
}

Ex004.cpp
#include
#include
using namespace std;
class Matherr {
public:
virtual

void debug_print() const {
cout << "Math_error" << endl;
}
};
class Int_overflow : public Matherr {
const char* op;
int a1, a2;
public:
Int_overflow(const char* p, int a, int b) : op(p), a1(a), a2(b) {}
virtual void debug_print() const {
cout << "Int_overflow: " << op << '(' << a1 << ',' << a2 << ')' << endl;
}
};
int add(int x, int y) {
if((x > 0 && y > 0 && x > INT_MAX-y) || (x < 0 && y < 0 && x < INT_MIN-y))
throw Int_overflow("+", x, y);
return x+y;
}
// Продолжение на следующем слайде...

int i1 = add(1, 2);
int i2 = add(INT_MAX,

-2);
int i3 = add(INT_MAX, 2);
}
catch(Matherr& m) {
//catch(Matherr m) {
m.debug_print();
}
}
int main() {
f();
return 0;
}

за блоком try, не соответствует типу исключения, то исключение передается

в контекст следующего уровня (выше по цепочке вызовов), пока не будет найден подходящий обработчик. Если такой обработчик не находится, автоматически вызывается стандартная библиотечная функция terminate(), которая, в свою очередь, вызывает функцию abort() из стандартной библиотеки С, что приводит к аварийному завершению программы (при этом деструкторы глобальных и статических объектов не вызываются!).

Функция terminate() также запускается в том случае, если деструктор локального объекта генерирует исключение в процессе раскрутки стека (во время обработки текущего исключения).

!!! Можно заменить стандартную функцию terminate() собственной версией подобной функции при помощи стандартной функции set_terminate()

std;
void MyTerminate() {
cout

(*old_terminate)() = set_terminate(MyTerminate);
class BadClass {
public:
class A{};
void f() {
cout << "inside BadClass::f()" << endl;
throw A();
}
~BadClass() {
cout << "inside ~BadClass()..." << endl;
throw 'c';
}
};
int main() {
try { BadClass b; b.f(); }
catch(...) { cout << "inside catch(...)" << endl; }
}

что нормальный ход программы прерывается и управление сразу передается в

подходящий обработчик. Одна польза от этого будет , если в момент запуска исключения будет произведена необходимая деинициализация (разрушение объектов, зачистка).
Механизм обработки исключений С++ гарантирует, что при выходе из области видимости для всех объектов этой области, конструкторы которых завершены, будут вызваны деструкторы.
Следующий пример программы показывает, что для объектов с незавершенными конструкторами деструкторы не вызываются.

static int counter;
int objid;
public:
Trace() {

objid = counter++;
cout << "constructing Trace #" << objid << endl;
if(objid == 3) throw objid;
}
~Trace() { cout << "destructing Trace #" << objid << endl; }
};
int Trace::counter = 0;

int main() {
try {
Trace n1;
Trace array[5]; // Не все эл. создаются
Trace n2; // Сюда не попадаем
}
catch(int i) { cout << "caught " << i << endl; }
}

том, что нормальный ход программы прерывается и управление сразу передается

в подходящий обработчик. Однако польза от этого будет , если в момент запуска исключения будет произведена необходимая деинициализация (разрушение объектов, зачистка).
Механизм обработки исключений С++ гарантирует, что при выходе из области видимости для всех объектов этой области, конструкторы которых завершены, будут вызваны деструкторы.
Следующий пример программы показывает, что для объектов с незавершенными конструкторами деструкторы не вызываются.

namespace std;
class Cat {
public:
Cat() { cout

endl; }
~Cat() { cout << "~Cat()" << endl; }
};
class Dog {
public:
void* operator new(size_t sz) {
cout << "allocating a Dog" << endl; throw 47; // Имитация нехватки памяти
}
void operator delete(void* p) {
cout << "deallocating a Dog" << endl; ::operator delete(p);
}
};
class UseResources {
Cat* bp;
Dog* op;
public:
UseResources(int count = 1) {
cout << "UseResources()" << endl;
bp = new Cat[count]; op = new Dog;
}
~UseResources() {
cout << "~UseResources()" << endl;
delete [] bp; // Уничтожение массива
delete op;
}
};
int main() {
try { UseResources ur(3); }
catch(int) { cout << "inside handler" << endl; }
} // В результате имеем 4 зависших указателя!

как это было в предыдущей программе, необходим о отказаться от

«низкоуровневого» выделения ресурсов одним из следующих способов:
перехват исключений внутри конструктора с последующим освобождением ресурса;
выделение ресурсов только в конструкторе объекта, чтобы освобождение ресурсов могло выполняться внутри деструктора.
Во втором варианте каждая операция выделения ресурсов становится «атомарной» (является частью жизненного цикла локального объекта). Если выделение ресурса завершается неудачей, другие объекты будут корректно уничтожены в процессе раскрутки стека. Эта методика называется получением ресурсов при инициализации.
В следующей программе эта задача решается с помощью шаблона – «обертки» для указателей. Конструкторы объектов, созданных на основе данного шаблона, вызываются до основного кода конструктора UseResurces, и для любого конструктора, завершившегося до возникновения исключения, в процессе раскрутки стека будет вызван соответствующий деструктор.

указатели
#include
#include
using namespace std;
template

class PWrap {// Шаблон – «обертка» для указателей
T* ptr;
public:
class RangeError {}; // класс исключения
PWrap() {
ptr = new T[sz];
cout << "PWrap constructor completed" << endl;
}
~PWrap() {
delete [] ptr;
cout << "PWrap destructor completed" << endl;
}
T& operator[](int i) throw(RangeError) {
if(i >= 0 && i < sz) return ptr[i];
throw RangeError();
}
};
// Продолжение на следующем слайде ...

слайде …
class Cat {
public:
Cat() { cout

endl; }
~Cat() { cout << "~Cat()" << endl; }
};

class Dog {
public:
void* operator new[](size_t) { // Имитация нехватки памяти
cout << "Allocating a Dog" << endl;
throw 47;
}
void operator delete[](void* p) {
cout << "Deallocating a Dog" << endl;
::operator delete[](p);
}
};
// Продолжение на следующем слайде …

3> cats; // Создаем 3 «кота»
PWrap dog; // Создаем

одну «собаку», и при вызове перегруженной операции
// new получаем исключение...
public:
UseResources() {
cout << "UseResources()" << endl;
}
~UseResources() {
cout << "~UseResources()" << endl;
}
};

int main() {
try {
UseResources ur;
}
catch(int) {
cout << "inside handler" << endl;
}
catch(...) {
cout << "inside catch(...)" << endl;
}
}

достаточно часто. Пусть, например, мы хотим обработать исключения, происходящие при

инициализации вложенных объектов или подобъектов базовых классов.
Для этого инициализация таких подобъектов заключается в блоки try уровня функций.
В отличие от обычного синтаксиса, блоком try для инициализаторов конструкторов является само тело конструктора (см. пример на след. слайде).

using namespace std;
class Base {
int i;
public:
class BaseExcept {};

Base(int i) : i(i) { throw BaseExcept(); }
};
class Derived : public Base {
public:
class DerivedExcept {
const char* msg;
public:
DerivedExcept(const char* msg) : msg(msg) {}
const char* what() const { return msg; }
};
Derived(int j) try : Base(j) {
cout << "This won't print" << endl;
}
catch (BaseExcept&) {
throw DerivedExcept("Base subobject threw");;
}
};
int main() {
try { Derived d(3); }
catch (Derived::DerivedExcept& d) { cout << d.what() << endl; }
}

создание блоков try уровня функции для любых функций, в том

числе и для main:

// Блоки try уровня функций
#include
using namespace std;
int main() try {
cout << "start main..." << endl;
throw "exception main";
}
catch(const char* msg) {
cout << msg << endl;
return 1;
}

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

исключения, чем пытаться определять собственный класс. Даже если стандартный класс делает не совсем то, что нужно, на его основе всегда можно создать производный класс.
Все стандартные классы исключений в конечном счете являются производными от класса exception (см. след. слайд). Его основными подклассами являются logic_error и runtime_error, которые имеют конструкторы со строковыми аргументами. Это позволяет сохранить сообщение в объекте исключения и извлечь его позднее с помощью функции exception::what().

#include
using namespace std;

class MyError : public runtime_error {
public:
MyError(const

string& msg = "") : runtime_error(msg) {}
};

int main() {
try {
throw MyError("my message");
}
catch (MyError& x) {
cout << x.what() << endl;
}
}