Различение особых ситуаций

9.2 Различение особых ситуаций

Естественно, в программе возможны несколько различных динамических

ошибок. Эти ошибки можно сопоставить с особыми ситуациями, имеющими

различные имена. Так, в классе Vector обычно приходится выявлять

и сообщать об ошибках двух видов: ошибки диапазона и ошибки,

вызванные неподходящим для конструктора параметром:

int* p;

public:

class Range { }; // особая ситуация индекса

class Size { }; // особая ситуация "неверный размер"

Vector(int sz);

int& operator[](int i);
// ...

};
Как было сказано, операция индексации запускает особую ситуацию

Range, если ей задан выходящий из диапазона значений индекс.

Конструктор запускает особую ситуацию Size, если ему задан

недопустимый размер вектора:
Vector::Vector(int sz)

{

if (sz<0 || max

// ...

}
Пользователь класса Vector может различить эти две особые ситуации,

если в проверяемом блоке (т.е. в блоке оператора try) укажет

обработчики для обеих ситуаций:

{

try {

}

catch (Vector::Range) {

}

catch (Vector::Size) {

}

}

обработчик. Если управление дойдет до конца операторов обработчика,

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

обработчиков:

{

try {

}

catch (Vector::Range) {

// попробовать опять:

f();

}

catch (Vector::Size) {

exit(99);

}

// сюда мы попадем, если вообще не было особых ситуаций

}
Список обработчиков напоминает переключатель, но здесь в теле

обработчика операторы break не нужны. Синтаксис списка обработчиков

отличен от синтаксиса вариантов case переключателя частично по

этой причине, частично потому, чтобы показать, что каждый

обработчик определяет свою область видимости (см. $$9.8).

Не обязательно все особые ситуации перехватывать в одной функции:
void f1()

{

try {

}

catch (Vector::Size) {

}

}

{

try {

}

catch (Vector::Range) {

}

}

use_vectors(), а особая ситуация Size будет оставлена для f1().

С точки зрения языка особая ситуация считается обработанной сразу

при входе в тело ее обработчика. Поэтому все особые ситуации,

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

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

Значит в следующем примере не возникнет бесконечного цикла:
try {

// ...

catch (input_overflow) {

// ...

throw input_overflow();

Обработчики особых ситуаций могут быть вложенными:

// ...

catch (xxii) {

try {

// сложная реакция

catch (xxii) {

// ошибка в процессе сложной реакции

}

}

и чаще всего она является свидетельством плохого стиля.

9.3 Имена особых ситуаций

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

запускается ведь не тип, а объект. Если нам нужно передать некоторую

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

поместить в запускаемый объект. Например, допустим нужно знать

значение индекса, выходящее за границы диапазона:

class Vector {

// ...

public:

class Range {

public:

int index;

Range(int i) : index(i) { }

};

// ...

int& operator[](int i)

// ...

};
int Vector::operator[](int i)

{

if (o<=i && i

throw Range(i);

}
Чтобы исследовать недопустимое значение индекса, в обработчике

нужно дать имя объекту, представляющему особую ситуацию:
void f(Vector& v)

{

// ...

try {

do_something(v);

}

catch (Vector::Range r ) {

cerr << "недопустимый индекс" << r.index << '\n';

// ...

}

// ...

}
Конструкция в скобках после служебного слова catch является по сути

описанием и она аналогична описанию формального параметра функции.

В ней указывается каким может быть тип параметра (т.е. особой

ситуации) и может задаваться имя для фактической, т.е. запущенной,

особой ситуации. Вспомним, что в шаблонах типов у нас был выбор

для именования особых ситуаций. В каждом созданном по шаблону классе

был свой класс особой ситуации:
template class Allocator {

// ...

class Exhausted { }

// ...

T* get();

};
void f(Allocator& ai, Allocator& ad)

{

try {

// ...

}

catch (Allocator::Exhausted) {

// ...

}

catch (Allocator::Exhausted) {

// ...

}

}

С другой стороны, особая ситуация может быть общей для всех

созданных по шаблону классов:

class Allocator_Exhausted { };
template class Allocator {

// ...

T* get();

};
void f(Allocator& ai, Allocator& ad)

{

try {

// ...

}

catch (Allocator_Exhausted) {

// ...

}

}

Какой способ задания особой ситуации предпочтительней, сказать трудно.

Выбор зависит от назначения рассматриваемого шаблона.

жүктеу/скачать 3.27 Mb.

Достарыңызбен бөлісу: