class C3DModel
{
private:
      // Some private data here:
      ...

public:
      class CFileNotFoundException
      {
      private:
            const char *FileThatWasNotFound;

      public:
            CFileNotFoundException(const char *FileName) : FileThatWasNotFound(FileName) { }
            const char *WhichFile() const { return FileThatWasNotFound; }
      };

public:
      // Constructor:
      C3DModel(const char *FileName = NULL)
      {
            // Делаем здесь что-то:
            ...

            // Пытаемся открыть файл и если файл не найден, то "кидаем" исключение:
            int ret = ::TryToOpenFile(FileName);
            if (ret == ERROR)
                    throw CFileNotFoundException(FileName); // Дадим пользователю знать какой файл мы
                                                            // не смогли найти. ТАКЖЕ, БУДЬ ОСТОРОЖНА С
                                                            // throw В КОНСТРУКТОРЕ! МОЖЕТ ПРОИЗОЙТИ RESOURCE
                                                            // LEAK!!!
            // Делаем здесь еще что-то если все в порядке:
            ...
      }

      ~C3DModel() { ... }

      void Load3DModelFile(const char *FileName)
      {
            // Код аналогичен коду в конструкторе...
      }

      void Animate3DModel() const { ... }
};

int main()
{
      try {
            C3DModel MyMonster("UglyMonster.3dm");
            MyMonster.Animate3DModel();  // Исполняется если файл был открыт успешно
      }
      catch (const C3DModel::CFileNotFoundException &e) {
            // Эта ветка исполнится если мы не смогли загрузить монстра...

            // Сообщим об ошибке!
            cerr << "Failed to load file " << e.WhichFile() << endl;

            // Сделаем еще что-нибудь тут:
            ...

            return 1;
      }

      return 0;
}

try
 {
  // КАКОЙ-ТО КОД, В КОТОРОМ МОЖЕТ СЛУЧИТСЯ ОШИБКА
 }
catch(...)
 {
  // ЛОВИМ ВСЕ ОШИБКИ
 }

if (не ошибки)
 {
  // ЧТО-ТО СДЕЛАТЬ
 }
else
 {
  // ПРИБРАТЬ ЗА СОБОЙ
 }

void func()
 {
  throw 0; // Собственно сгенерировали исключение.
 }
////////////
void func2()
 {
  try
   {
    func();
   }
  catch
   {
   }
 }

int * p = NULL;
*p = 3;

catch(...)

catch(int)
///////////////////////////////
catch(CMyException, int, float)

////////////////////////
Загрузить и обработать данные.
////////////////////////
void DoAllWork()
 {
  try
   {
    LoadData();
   }
  catch(LoaderError)
   {
    throw CanNotLoad;
   }
  Process();
 }
///////////////////////
Загрузить
///////////////////////
void LoadData()
 {
  while (true)
   {
    try
     {
      AllocateMemoryAndReadFile();
      break;
     }
    catch(NoEnoghtMemory)
     {
      try
       {
         WriteSomeDataToHDD();
       }
      catch(IOError)
       {
        throw LoaderError;
       }
     }
   }
 }
///////////////////////
Обработать
///////////////////////
void Process
 {
  if (datalength < 100) throw CanNotProcess;
 }

main(void) - головная функция
parser_text(char *file_name) - парсер всего текста
parser_str(char *str) - парсер отдельной строки

char ss[16]; // строка с ошибкой
int pos=0; // текущая позиция в строке
try{
  // Код потенциально пораждающий ошибку
   ...
  pos++;
}
catch(...){
  // Поймали ошибку, передаем информацию об ошибке вызывающей функции
  itoa(ss,pos,16);
  throw ss;
}

int pos=0;
char error[50]; // текст ошибки
try{
  // Парсер строки
  parser_str(str);
  ...
  pos++;
}
catch(char * ss){
  // Поймали ошибку, передаем информацию об ошибке вызывающей функции
  // добавляем информацию на данном уровне в переменную error
  ...
  throw error;
}

try{
  // Парсер строки
  parser_text(str);
}
catch(char *ss){
  // Выводим ошибку
  cout << "Ошибка в строке" << ss;
}

try
{ ... }
catch(some_exception_type ex)
{ ... }

throw some_exception_type(ctor-args);

struct ComException
{
  HRESULT hr_; // экземпляр несёт сведения о подробностях случившегося
  ComException(HRESULT hr) : hr_(hr) {}
};
// удобная функиция-швырялка (см. ниже)
void TestHresult(HRESULT hr) { if(FAILED(hr) throw ComException(hr); }

.....

// функция возвращает нечто полезное: int, но при этом может кинуть исключение.
int fun()
{
  // там, где "плохой" HRESULT является содержательным и подлежит анализу,
  // или там, где нам пофиг - мы не будем выполнять TestHresult.

  CComPtr<IXXX> pXXX;
  TestHresult( pXXX.CoCreateInstance(CLSID_TheXXX) );

  int v;
  TestHresult( pXXX->GetSomeValue(&v) );

  return v;
}

void main()
{
  try
  {
    int v = fun();
    cout << "fun() == " << v << endl;
  }
  catch(ComException ex)
  {
    cout << "fun() reports an error, HRESULT = 0x" << hex << ex.hr_ << endl;
  }
}

К>try
К>{ ... }
К>catch(some_exception_type ex)
К>{ ... }
К>

К>throw some_exception_type(ctor-args);
К>

try
{ ... }
catch(some_exception_type &ex)
{ ... }

Глава 4. Исключения
Не бывает правил без исключений
Народный фольклор

При выполнении любой программы бывают аварийные ситуации, вызванные самыми разнообразными причинами. Если мы делаем программу "для себя", то встроить в нее обработку некоторых ошибок с выдачей сообщений труда не представляет. Но в профессиональном программировании программы чаще пишутся не для себя, а для других, поэтому такой метод обработки ошибок неприемлем.

Принципы обработки исключений

В С++ исключение — это объект. Хотя обычно говорят об исключительной ситуации в программе, такая точка зрения мало что дает, так как с ситуацией сделать ничего нельзя. Поэтому в С++ при возникновении исключительной ситуации программа должна генерировать объект-исключение. Собственно, сама генерация объекта-исключения и создает исключительную ситуацию. Такой подход очень удобен, так как с объектами, в отличие от ситуации, мы можем много чего делать. Например, объявлять как обычную переменную, передать его как параметр любым из возможных способов или возвратить в качестве результата. Можно объявлять массивы исключений или включать объекты исключения в качестве полей в другие классы. В дальнейшем мы иногда будем использовать термин "исключение", понимая под этим объект-исключение.

Общая схема обработки исключений такова: в одной части программы, где обнаружена аварийная ситуация, исключение генерируется; другая часть программы, которая следит за возникновением исключения, ловит и обрабатывает его. В С++ есть три зарезервированных слова: try (контролировать), catch (ловить), throw (порождать), — которые и используются для организации процесса обработки исключений.
Генерация исключений

Генерируется исключение оператором throw, который имеет следующий синтаксис

throw выражение_генерации_исключения;

Фраза "выражение_генерации_исключения" на практике означает либо константу, либо переменную некоторого типа. Тип объекта-исключения может быть любым, как встроенным, так и определяемым программистом. Например,

throw 7;
throw "Ошибка: деление на ноль!";
throw Message[i];
throw M_PI;

В первом случае объект-исключение — это целая константа, которая может быть условным номером-кодом ошибки. В общем случае этот код ошибки может вычисляться, например

throw 3*v-i;

Выражение, конечно, может быть не только целочисленным.
Второй вариант — это символьная константа, которая фактически является сообщением об ошибке. Если все сообщения об ошибках записаны в массиве, например,

string Message[326];

то в третьем варианте объект-исключение тоже представляет собой строку — сообщение об ошибке. В последнем примере в качестве объекта используется дробная константа — число p.
Программист может и сам определить свой собственный тип объекта-исключения, объявив новый класс, например

class NegativeArgument{};
NegativeArgument exeption;
if (x>0) double t = x/sqrt(x);
else throw exeption;

Пустые классы неожиданно пригодились! Однако объявлять переменную совсем не обязательно, можно обойтись и без этого, например

throw NegativeArgument();

Здесь в качестве "выражения генерации исключения" мы использовали явный вызов конструктора без аргументов, и это наиболее часто используемая форма генерации исключения.
Объект-исключение может быть и динамическим, например,

throw new NegativeArgument();

Соответственно в программе должен быть объявлена секция-ловушка, в которой параметр передается по указателю. Однако такая практика приводит к проблемам с возвратом памяти, поэтому лучше не создавать себе головной боли и не использовать указатели в качестве параметров catch-блоков.

Перехват и обработка исключений

Сгенерировать исключение — это только полдела. Исключение надо перехватить и обработать. Проверка возникновения исключения делается с помощью оператора try, с которым неразрывно связаны одна или несколько секций-ловушек catch. Оператор try объявляет в любом месте программы контролируемый блок, который имеет следующий вид

try { /* контролируемый блок */ }

Контролируемый блок, помимо функции контроля, обладает функциями обычного блока: все переменные, объявленные внутри него, являются локальными в этом блоке и не видны вне его.
После try-блока обязательно прописывается один или несколько catch-блоков, которые обычно называют обработчиками исключений. Форма записи секции-ловушки следующая:

catch (спецификация_исключения) { /* блок обработки */}

Спецификация_исключения может иметь следующие три формы:
(тип имя)
(тип)
(…)
Тип должен быть одним из допустимых типов исключений — либо встроенный, либо определенный программистом. Первый вариант спецификации означает, что объект-исключение передается в блок обработки, чтобы там его как-то использовать, например, для вывода информации в сообщении об ошибке. При этом объект-исключение может передаваться в секцию-ловушку любым способом: по значению, по ссылке или по указателю, например

catch (TException e)            // по значению
catch (TException& e)            // по ссылке
catch (const TException& e)        // по константной ссылке
catch (TException *e)            // по по указателю

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

catch (double e)            // по значению

то попадают в эту секцию только те исключения, тип выражения исключений которых совпадает с double. Оператор

throw 1

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

catch (int e)            // по значению

или

catch (int)                // без передачи информации в секцию-ловушку

Во втором варианте спецификации исключения объект-исключение в блок обработки не передается и никак не используется — исключения перехватываются по типу.
Первые две формы предназначены для обработки конкретного типа исключений. Если же на месте спецификации исключения написано многоточие (как в функциях с переменным числом параметров), то такой обработчик перехватывает все исключения.
Работа конструкции try-catch напоминает работу оператора switch. Секции-ловушки похожи на альтернативы case, а catch-блок с многоточием соответствует альтернативе default оператора-переключателя. Если в try-блоке возникает исключение, то начинается сравнение типа сгенерированного исключения и типов параметров в секциях-ловушках. Выполняется тот catch-блок, тип параметра которого совпал с типом исключения. Если такого типа не найдено, но есть catch с многоточием, то выполняется его блок. Если же такого блока нет, то вызывается стандартная функция завершения terminate().
Таким образом, очень важен порядок записи секций-ловушек после контролируемого блока. Если в качестве первого обработчика после try-блока задан catch-блок с параметром-многоточием, то такой обработчик будет обрабатывать все возникающие исключения. До остальных секций-ловушек дело просто не дойдет. Поэтому усвойте следующее простое правило: всегда задавать catch-блок с параметром-многоточием последним.
Выход из секции-ловушки выполняется одним из следующих способов:
1. выполнились все операторы обработчика — происходит неявный переход на оператор, расположенный после конструкции try-catch;
2. в обработчике выполняется оператор goto; разрешается выполнять оператор на любой оператор вне конструкции try-catch; внутрь контролируемого блока и в другую секцию ловушку переход запрещен;
3. в секции ловушке выполняется оператор throw;
4. в обработчике генерируется другое исключение;
После выполнения операторов catch-блока при отсутствии явных операторов перехода или оператора throw выполняются операторы, расположенные после всей конструкции try-catch. Если во время работы в try-блоке не обнаружено исключительной ситуации, то все catch-блоки пропускаются, и программа продолжает выполнение с первого оператора после всех catch.
Интересно, что можно объявлять контролируемым блок, являющийся телом функции. Например, мы можем контролировать все исключения, возникающие в теле главной функции, написав такую конструкцию:

int main()
try { // контролируемый блок – тело функции
      // …
    }
catch(...)
{ // сообщения об исключениях
}

Если в контролируемом блоке не возникнет исключений, то блок функции нормально завершается. Если же исключения возникнут, то, как обычно, выполняется секция-ловушка, и только после этого программа завершается. Секций-ловушек, естественно, может быть прописано столько, сколько необходимо.
В стандарте [1] приводится следующий пример на ту же тему (листинг 4.1).

//Листинг 4.1. Контролируемый блок — тело функции
int f(int);                    // функция, определенная в другом месте
class C
{ int i; double d;                // поля
  public:
    C(int, double);             // конструктор инициализации
// …
};
C::C(int ii, double id)            // реализация конструктора 
try                                // контролируем
:i(f(ii)), d(id)                // список инициализации
{   // …                        // тело конструктора
}
catch(…)
{     // …                            // обработчик исключений
}

В этом случае у нас отсутствуют операторы после блока try-catch. При такой организации конструктора первые два из перечисленных выше способов выхода из секции-ловушки просто невозможны. Поэтому в данном случае в catch-блоке конструктора обязательно должен присутствовать оператор throw. Однако нужно сказать, что не все системы поддерживают стандарт в полном объеме, поэтому такие возможности следует проверять в конкретной системе.
Блоки try-catch могут быть вложенными, причем как в try-блок, так и в catch-блок:

try {    // блок, который может инициировать исключения
    try {     //вложенный блок
    }
    catch(…){    }
}
catch (исключение) {    // обработка исключения
    try {     //вложенный блок
    }
    catch(…){    }
}

Необходимо отметить, что исключение может быть сгенерировано в одном месте программы, а обработано совершенно в другом.
При обработке исключения в секции-ловушке можно сгенерировать повторное исключение того же типа — это делается оператором throw без выражения генерации исключения. Такая форма допустима только внутри секции-ловушки. Однако это не приводит к рекурсивному входу в тот же обработчик — ищется другой обработчик выше по иерархии вложенности. Если такого обработчика нет, то программа аварийно завершается. Таким образом, мы имеем возможность "распределить" обработку исключения по разным частям программы.

Текст функции с программой-клиентом представлен в листинге 4.3.

//Листинг 4.3 Функция вычисления высоты треугольника с генерацией исключений
double Ha(double a, double b, double c)
{ if ((a>0)&&(b>0)&&(c>0))                    // если параметры правильные 
  { if ((a+b>c)&&(a+c>b)&&(b+c>a))             // если треугольник
    { double p = (a+b+c)/2;                    // вычисление высоты
      return 2*sqrt(p*(p-a)*(p-b)*(p-c))/a;  
    }
    else throw "Не треугольник!";            // генерируем исключение
  }
  else throw "Неправильный параметр!";        // генерация исключения
}
int main()
{ try {                            // контролируемый блок
    cout <<Ha(3,4,5)<< endl;        // нормальное вычисление
    cout <<Ha(1,2,3)<< endl;    // генерирует исключение
    cout <<Ha(1,0,3)<< endl;        // не выполняется!
  } 
  catch(const char *s)            // обработка исключения
  { cout << s << endl; }
  return 0;
}

Обратите внимание на то, что в функции не выполняется возврат "аварийного значения" 0 — в данном случае этого не требуется, так как оператор генерации исключения осуществляет выход из функции. При этом выполняется обычный процесс уничтожения локальных объектов, и вызываются все необходимые деструкторы. Этот процесс уничтожения локальных объектов при выходе по исключению называется "раскруткой" стека. Поэтому вернуться в функцию после генерации исключения невозможно — разве что заново ее вызвать.
Первый оператор вывода срабатывает нормально. Во время выполнения второго возникает исключение, и управление передается в секцию-ловушку. При этом пропускается третий оператор вывода. И мы не можем "вернуться" к его выполнению после выполнения секции-ловушки, даже если пометим его, и напишем оператор goto, — по стандарту оператор goto не может использоваться для перехода внутрь контролируемого блока. Но можно передать управление на начало try-блока и выполнить весь контролируемый блок сначала. Правда, в данном случае — без корректировки параметров во втором вызове — это не изменит поведения программы: третий оператор все равно не будет работать.

Наша функция не имеет спецификации исключений. Наличие спецификации в заголовке, например,

double Ha(double a, double b, double c) throw(const char *)

никак не изменяет поведения программы.
Если мы напишем спецификацию исключения с типом исключения, не соответствующим типу генерируемого, то программа должна закончится аварийно. Однако не все системы поддерживают это требование стандарта. В частности, Visual C++.NET 2003 задание спецификация с другим типом исключения, например,

double Ha(double a, double b, double c) throw(string)

или вовсе запрещающая исключения

double Ha(double a, double b, double c) throw()

никак не влияет на видимое поведение программы. Главное, чтобы генерируемое исключение было где-нибудь перехвачено.

Передача информации в блок обработки

При обработке исключения в нашей программе просто выводится сообщение. Однако чрезвычайно полезно иметь дополнительную информацию об ошибке. Например, бывает необходимо знать конкретные значения параметров функции, которые вызвали сбой программы. Однако параметр в секцию ловушку передается только один — объект-исключение. Поэтому, чтобы передать в блок обработки больше информации, мы должны реализовать собственный тип исключений в виде полноценного класса. Этот класс, естественно, должен быть специализирован под задачу.
В нашем случае, кроме сообщения, полезно передать в блок обработки вместе с объектом-исключением значения параметров, которые получила функция (стороны треугольника) и которые вызвали генерацию исключения. Для этого надо в классе-исключении объявить поля и определить конструктор инициализации. В листинге 4.4 представлен текст этого класса-исключения вместе с функцией и тестовой программой.

//Листинг 4.4 Класс-исключение. Передача информации в обработчик  
struct ErrorTriangle
{ double a, b, c;                    // параметры функции
  string message;                    // сообщение
// конструктор
ErrorTriangle(double x, double y, double z, const string& s)
: a(x), b(y), c(z), 
  message(s) {}            // пустое тело
}
// указана спецификация исключений
double Ha(double a, double b, double c) throw(ErrorTriangle) 
{ if ((a>0)&&(b>0)&&(c>0)) 
  { if ((a+b>c)&&(a+c>b)&&(b+c>a)) 
    { double p = (a+b+c)/2;    
      return 2*sqrt(p*(p-a)*(p-b)*(p-c))/a;  
    }
    else throw ErrorTriangle(a,b,c,"Не треугольник!");       // конструктор
  }
  throw ErrorTriangle(a,b,c,"Неправильные параметры!");        // конструктор
}
int main()
{ try {
    cout <<Ha(3,4,5)<< endl;                    // нормально выполняется
    cout <<Ha(1,2,3)<< endl;                // вызывает исключение
    cout <<Ha(1,0,3)<< endl;                    // не выполняется
  } 
  catch(const ErrorTriangle& e)                // получаем полноценный объект
  { cout << e.message << endl;                // используем поля
    cout << e.a <<' '<< e.b <<' '<< e.c << endl;
  }
}

Класс-исключение определен с помощью структуры для того, чтобы в обработчике не иметь проблем с доступом к полям. Три поля double соответствуют сторонам треугольника, а еще одно поле — для сообщения об ошибке. Теперь мы можем использовать для сообщений тип string, так как в структуре объявлен конструктор инициализации, который и заполняет поля. При передаче в конструктор символьной константы как параметра и выполняется преобразование в string.
В операторе throw в качестве выражения генерации исключения прописан явный вызов конструктора. Секция-ловушка получает объект по константной ссылке и использует информацию, предоставленную конструктором для вывода значений на экран.

Напишем несколько функций, последовательно вызывающих друг друга. В каждой функции создадим "умный" массив с помощью конструктора копирования (чтобы конструктор не вызывался при передаче параметров, их будем передавать по константной ссылке). В самой "внутренней" функции сгенерируем исключение. И наконец, в главной программе будем ловить и обрабатывать возникающие исключения (листинг 4.9).

//Листинг 4.9. Проверка "раскрутки" стека
TArray f2 (const TArray &t)                // самая "внутренняя" функция
{ cout << "function f2" << endl;        // отслеживаем вход
  TArray r(t);                            // конструируем массив
  cout << r << endl;                    // выполняется
  throw TArray::bad_Index();            // генерация исключения
  return r;                                // не выполняется!!!!!
}
TArray f1 (const TArray &t)
{ cout << "function f1" << endl;        // отслеживаем вход
  TArray R[] = { t, t, t };              // создается три массива
  cout << R[0] << endl;                    // выполняется
  cout << R[1] << endl;                    // выполняется
  cout << R[2] << endl;                    // выполняется
  TArray r = f2(t);                        // r не создается – не "успевает"
  return r;                                // не выполняется!!!!!
}
TArray f(const TArray& a)
{ cout << "function f" << endl;            // отслеживаем вход
  TArray t = f1(a);                        // t не создается – не "успевает"
  cout << t << endl;                    // не выполняется!!!!
  return t;                                // не выполняется!!!!
}
int main()
{ double a[5] = {1,2,3,4,5};
  TArray B(a, a+(sizeof(a)/sizeof(double)));
  try { f(B);                            // контролируем 
  }
// секции-ловушки
  catch(TArray::bad_Index) {cout <<"Индекс плохой!"<< endl;}
  catch(TArray::bad_Range) {cout <<"Диапазон плохой!"<< endl;}
  catch(TArray::bad_Size)  {cout <<"Размер плохой!"<< endl;}
// непредвиденное исключение  
  catch(...){cout <<"Exceptions!"<< endl;}
  return 0;
}

При запуске программы мы увидим на экране следующий вывод:

function f
function f1
Конструктор-копирования!
Конструктор-копирования!
Конструктор-копирования!
1 2 3 4 5
1 2 3 4 5
1 2 3 4 5
function f2
Конструктор-копирования!
1 2 3 4 5
Destuctor
Destuctor
Destuctor
Destuctor
Индекс плохой!
[/ccode]

Последовательность действий в этом примере следующая:
q    в главной функции объявляется массив a и из него конструируется "умный" массив B;
q    выполняется вход в контролируемый блок и вызов функции f, которой передается параметр — "умный" массив B;
q    в функции первым выполняется оператор вывода и на экране появляется первая строка "function f";
q    во второй строке функции f прописано объявление "умного" массива t, однако до вызова конструктора дело не доходит, так как вызывается функция f1;
q    первый оператор функции f1 выводит на экран строку "function f1";
q    далее в функции f1 создается массив R из трех "умных массивов, и конструктор копирования вызывается трижды; 
q    выполняется вывод на экран трех элементов-массивов;
q    далее прописано объявление "умного" массива r, однако вызова конструктора не происходит, так как вызывается функция f2;
q    функция f2 выводит на экран строку "function f2";
q    создается локальный "умный" массив r, конструктор копирования отрабатывает один раз;
q    содержимое массива r выводится на экран;
q    генерируется исключение bad_Index;

В этот момент у нас создан один локальный массив в функции f2 и массив R из трех массивов в функции f1, которые находятся в стеке. При генерации исключения деструктор вызывается четыре раза, что мы и наблюдаем на экране. После этого происходит переход в секцию-ловушку и выводится строка "Плохой индекс". Затем выполняется выход из секции в тело главной функции, и программа завершает работу.
Теперь распределим обработку исключения по разным функциям. Добавим в функцию f1 контролирующий блок, и идентифицируем вывод в секции-ловушке в главной программе (листинг 4.10). 
[ccode]
//Листинг 4.10. Распределенная обработка исключения
TArray f1 (const TArray &t)
{ cout << "function f1" << endl;
  TArray R[] = { t, t, t };  
  cout << R[0] << endl;
  cout << R[1] << endl;
  cout << R[2] << endl;
  try {                             // контролируем вызов f2
        TArray r = f2(t);            // локальный объект
        return r;                    // норамальное завершение
  }
  catch(TArray::bad_Index) 
  { cout <<"f1. Плохой индекс!"<< endl; 
    throw;                            // повторная генерация исключения
  };
 }
int main()
{ double a[5] = {1,2,3,4,5};
  TArray B(a, a+(sizeof(a)/sizeof(double)));
  try { f(B);                            // контролируем 
  }
// секции-ловушки
  catch(TArray::bad_Index) {cout <<"Main. Индекс плохой!"<< endl;}
  catch(TArray::bad_Range) {cout <<"Диапазон плохой!"<< endl;}
  catch(TArray::bad_Size)  {cout <<"Размер плохой!"<< endl;}
// непредвиденное исключение  
  catch(...){cout <<"Exceptions!"<< endl;}
  return 0;
}
[/ccode]
                        
Остальные функции оставим без изменения. При запуске этой программы на экране появится следующее:
[code]
function f
function f1
Конструктор копирования!
Конструктор копирования!
Конструктор копирования!
1 2 3 4 5
1 2 3 4 5
1 2 3 4 5
function f2
Конструктор копирования!
1 2 3 4 5                        // до этого момента поведение повторяется
Destuctor                        // при выходе из f2
f1. Плохой индекс!                // секция-ловушка в функции f1
Destuctor                        // выход из f1
Destuctor
Destuctor
Main. Плохой индекс!             // секция-ловушка в main

Поведение программы повторяется до генерации исключения. Выполнение оператора throw приводит к выходу из функции f2, при этом вызывается деструктор. В вызывающей функции обнаруживается секция-ловушка нужного типа, которая и выполняется. В конце ее срабатывает оператор повторной генерации исключения. Происходит выход из функции f1 — при этом трижды вызываются деструктор для уничтожения элементов массива R. В вызывающей функции — а это уже главная функция main, ищется секция-ловушка нужного типа. Она у нас в программе есть, и мы наблюдаем ее работу в последней строке, выведенной на экран.
В связи с тем, что деструктор вызывается для уничтожения объектов при генерации любого исключения, сам деструктор генерировать исключения не должен. Как указывает Герб Саттер [24], "все деструкторы должны разрабатываться так, как если бы они имели спецификацию исключения throw(), то есть ни одному исключению не должно быть позволено выйти за пределы деструктора". Если же это произойдет, то программа завершается аварийно.

//Листинг 4.11. Иерархия стандартных исключений
class exception {//… };
  class logic_error : public exception {//… };
     class domain_error : public logic_error {//… };
     class invalid_argument : public logic_error {//… };
     class length_error : public logic_error {//… };
     class out_of_range : public logic_error {//… };
  class runtime_error : public exception {//… };
     class range_error : public runtime_error {//… };
     class overflow_error : public runtime_error {
     class underflow_error : public runtime_error {//… };
  class bad_cast : public exception {//… };
  class bad_alloc : public exception {//… };
  class bad_tipeid : public exception {//… };
  class bad_exception : public exception {//… };
  class ios_base::failure : public exception {//… };

Эта иерархия служит основой для создания собственных исключений и иерархий исключений. Мы можем определять свои собственные исключения, унаследовав их от класса exception. Для работы со стандартными исключениями в программе надо прописать оператор
#include <stdexcept>
Класс exception определен в стандартной библиотеке следующим образом (листинг 4.12).

//Листинг 4.12. Стандартный класс исключения
class exception {
   public:
     exception () throw();
     exception (const exception&) throw();
     exception& operator= (const exception&) throw();
     virtual ~exception () throw();
     virtual const char* what () const throw();
 };

Что означает слово virtual, мы разберемся во второй части книги, а сейчас обратите внимание на то, что все конструкторы и методы имеют спецификацию, запрещающую генерацию исключений. Это и понятно — если механизм исключений сам будет генерировать исключения, хорошего ждать не приходится — программа закончится аварийно.
Как видим, стандартные исключения включают функцию-метод what(). Использование стандартных исключений продемонстрируем с помощью немного модифицированного примера из справочника интегрированной среды Borland C++ Builder 6 (листинг 4.13).

//Листинг 4.13. Использование метода what()
#include <stdexcept>
#include <iostream>
#include <string>
using namespace std;
void f()                     // функция, генерирующая исключение runtime
{ throw runtime_error("Ошибка runtime!"); }
int main ()
{ string s;
  try {                      // контролируем метод replace класса string
         s.replace(100,1,1,'c'); 
      }
  catch (const exception& e)
  { cout << "Получили исключение: " << e.what() << endl; }
  try {   f();                 // контролируем нашу функцию
      }
  catch (const exception& e)
  { cout << "Получили исключение: " << e.what() << endl; }
  return 0;
}

Эта программа выведет на экран две строки:

Получили исключение: basic_string
Получили исключение: a runtime error

Первая строка — это результат работы первого обработчика при неправильном использовании метода replace строки s, вторая – это уже результат явной генерации исключения типа runtime_error в функции f. Обратите внимание на одну замечательную особенность catch-блоков: в качестве типа формального параметра используется базовый класс, тогда как при выполнении в обработчик попадает объект-исключение совсем другого типа — наследника от базового. Это очень важное свойство наследования мы рассмотрим в следующей главе.

int status;
status = f1();
if (status != OK)
{
   report_status(status);
   kill them all;
}
status = f2();
if (status != OK)
{
   report_status(status);
   kill them all;
}
status = f3();
if (status != OK)
{
   report_status(status);
   kill them all;
}
status = f4();
if (status != OK)
{
   report_status(status);
   kill them all;
}
status = f5();
if (status != OK)
{
   report_status(status);
   kill them all;
}

int status;
status = f1();
if (status != OK) goto err;
status = f2();
if (status != OK) goto err;
status = f3();
if (status != OK) goto err;
status = f4();
if (status != OK) goto err;
status = f5();
if (status != OK) goto err;
goto all_ok;
err:
{
   report_status(status);
   kill them all;
}
all_ok:

int status;
bool all_ok = false;
status = f1();
if (status == OK)
{
   status = f2();
   if (status == OK)
   {
      status = f3();
      if (status == OK)
      {
         status = f4();
         if (status == OK)
         {
            status = f5();
            if (status == OK)
               all_ok = true;
         }
      }
   }
}
if !(all_ok)
{
   report_status(status);
   kill them all;
}

try
{
   f1();
   f2();
   f3();
   f4();
   f5();
}
catch(int status)
{
   report_status(status);
   kill them all;
}

LVV>class NegativeArgument{};
LVV>NegativeArgument exeption;
LVV>if (x>0) double t = x/sqrt(x);
LVV>else throw exeption;
LVV>

LVV>throw NegativeArgument();
LVV>

LVV>throw new NegativeArgument();
LVV>

LVV>catch (TException e)            // по значению
LVV>catch (TException& e)            // по ссылке
LVV>catch (const TException& e)        // по константной ссылке
LVV>catch (TException *e)            // по по указателю
LVV>

LVV>int main()
LVV>try { // контролируемый блок – тело функции
LVV>      // …
LVV>    }
LVV>catch(...)
LVV>{ // сообщения об исключениях
LVV>}
LVV>

LVV>//Листинг 4.1. Контролируемый блок — тело функции
LVV>int f(int);                    // функция, определенная в другом месте
LVV>class C
LVV>{ int i; double d;                // поля
LVV>  public:
LVV>    C(int, double);             // конструктор инициализации
LVV>// …
LVV>};
LVV>C::C(int ii, double id)            // реализация конструктора 
LVV>try                                // контролируем
LVV>:i(f(ii)), d(id)                // список инициализации
LVV>{   // …                        // тело конструктора
LVV>}
LVV>catch(…)
LVV>{     // …                            // обработчик исключений
LVV>}
LVV>

LVV>try {    // блок, который может инициировать исключения
LVV>    try {     //вложенный блок
LVV>    }
LVV>    catch(…){    }
LVV>}
LVV>catch (исключение) {    // обработка исключения
LVV>    try {     //вложенный блок
LVV>    }
LVV>    catch(…){    }
LVV>} 
LVV>

void foobar()
{
    throw;
}

void bar()
{
    try {
        throw Exception();
    }
    catch ( Exception & ) {
        foobar();
    }
}

void foo()
{
    try {
        bar();
    }
    catch ( Exception & ) {
    }
}

LVV>//Листинг 4.3 Функция вычисления высоты треугольника с генерацией исключений
LVV>double Ha(double a, double b, double c)
LVV>{ if ((a>0)&&(b>0)&&(c>0))                    // если параметры правильные 
LVV>  { if ((a+b>c)&&(a+c>b)&&(b+c>a))             // если треугольник
LVV>    { double p = (a+b+c)/2;                    // вычисление высоты
LVV>      return 2*sqrt(p*(p-a)*(p-b)*(p-c))/a;  
LVV>    }
LVV>    else throw "Не треугольник!";            // генерируем исключение
LVV>  }
LVV>  else throw "Неправильный параметр!";        // генерация исключения
LVV>}

double Ha(double a, double b, double c)
{
    if (a <= 0 || b <= 0 || c <= 0)
        throw exception("Неправельный параметр!");
    if (a + b <= c || a + c <= b || b + c <= a)
        throw exception("Не треугольник!");
    double p = (a + b + c) / 2;
    return 2 * sqrt(p * (p - a) * (p - b) * (p - c)) / a;
}

LVV>double Ha(double a, double b, double c) throw(const char *) 
LVV>

LVV>double Ha(double a, double b, double c) throw(string) 
LVV>

LVV>double Ha(double a, double b, double c) throw() 
LVV>

LVV>  } 
LVV>  catch(const ErrorTriangle& e)                // получаем полноценный объект
LVV>  { cout << e.message << endl;                // используем поля
LVV>    cout << e.a <<' '<< e.b <<' '<< e.c << endl;
LVV>  }
LVV>}
LVV>

try {
   f();
}
catch (const MyException& e)
{
   ...
}
catch (const HisException& e)
{
   ...
}
catch (const TheirException& e)
{
   ...
}
catch (const std::exception& e)
{
   ...
}
catch (...) // случилась какая-то фигня и хз что с ней делать, может, еще кто знает?
{
   cerr << "случилась какая-то фигня и хз что с ней делать, на всякий случай все чистим, роллбэчим, логгим и т.п.\n";
   ... // чистим, роллбэчим, логгим и т.п.
   throw; // теперь пусть другие пытаются сделать что-то более осмысленное
}

catch (unsigned int hardwareExceptionCode)

J>try
J>{
J>   f1();
J>   f2();
J>   f3();
J>   f4();
J>   f5();
J>}
J>catch(int status)
J>{
J>   report_status(status);
J>   kill them all;
J>}
J>

#define chkerr(x) do { if ( (x) != ERR_SUCCESS ) { ReportErrorAt(__FILE__,__LINE__,#x); goto lb_error;} } while(0)
/// здесь описаны явно удаляемые обьекты
{
   /// здесь описанны локальные обьекты, например умные указатели
   chkerr( f1() );
   chkerr( f2() );
   chkerr( f3() );
   chherr( f4() );
   chkerr( f5() );
   goto lb_end;
}
lb_error:
   /// обработка ошибочной ситуации
lb_end:
   /// делаем явное удаление обьектов

  if ( !f1()
    || !f2()
    || !f3()
    || !f4()
    || !f5() )
  {
    // обработка ошибки
  }

(/* [in] */                        DWORD dwCount
,/* [size_is][in] */            OPCITEMDEF *pItemArray
,/* [size_is][size_is][out] */    OPCITEMRESULT **ppAddResults
,/* [size_is][size_is][out] */    HRESULT **ppErrors
)
try
{
    scoped_lock(this);//лочим текущий объект//макрос
    com_check(owner_);//если проверка провалилась кидаем исключение
    com_check_ptr(pItemArray);
    com_check_ptr(ppAddResults);
    com_check_ptr(ppErrors);
    com_check_arg(dwCount>0);
    com_auto_arr<OPCITEMRESULT>    ir(dwCount);//выделяем память при помощи CoTaskMemAlloc//если не смогли кидаем исключение.
    com_auto_arr<HRESULT>        hr(dwCount);
    HRESULT res=S_OK;
    for(size_t i=0;i<dwCount;++i)
    {
        ref_t<CSRCOMM_OPCGroupItem> item=new CSRCOMM_OPCGroupItem(this);
        OPCHANDLE handle=get_new_handle();
        hr[i]=item->init(&pItemArray[i], &ir[i], handle);
        if(FAILED(hr[i]))
        {
            res=S_FALSE;
            ir[i].dwAccessRights        =0;
            ir[i].dwBlobSize            =0;
            ir[i].hServer                =-1;
            ir[i].pBlob                    =0;
            ir[i].vtCanonicalDataType    =VT_ERROR;
            ir[i].wReserved                =0;
        }
        else
            item_map_[handle]=item;
    }

//возвращаем результаты работы//исключений нет
    *ppAddResults    =ir.detach();
    *ppErrors        =hr.detach();
    return res;
}
com_catch_all()//расшифровываем исключение//макрос

    DWORD            dwNumItems,
    OPCITEMDEF     * pItemArray,
    OPCITEMRESULT ** ppAddResults,
    HRESULT       ** ppErrors
    )
{
    unsigned int    i;
    OPCITEMRESULT *ir;
    HRESULT *hr;
    SYSTEMTIME SystemTime;
    BOOL    ok = TRUE;
    COPCItem    *pItem;

    GetApp()->DisplayEvent ("IOPCItemMgt::AddItems");

    // First - allocate memory for the result array(s)
    //
    ir = (OPCITEMRESULT*)GetApp()->pIMalloc->Alloc(sizeof(OPCITEMRESULT) * dwNumItems);    //acc001
    if(ir == NULL)
        {
        *ppAddResults = NULL;
        *ppErrors = NULL;
        return (E_OUTOFMEMORY);
        }

    *ppAddResults = ir;

    hr = (HRESULT*) GetApp()->pIMalloc->Alloc(sizeof(HRESULT) *dwNumItems);        //acc001
    if (hr == NULL)
        {
        GetApp()->pIMalloc->Free(ir);    
        *ppAddResults = NULL;
        *ppErrors = NULL;
        return (E_OUTOFMEMORY);
        }

    *ppErrors = hr;

    // Now for each item... 
    //
    for(i=0; i<dwNumItems; i++)
        {
        hr[i] = GetApp()->ValidateItem (&pItemArray[i], &ir[i]);

        if (hr[i] == S_OK)
            {
            // Create a new OPCItem
            pItem = new (COPCItem);

            pItem->Name = pItemArray[i].szItemID;
            pItem->AccessPath = pItemArray[i].szAccessPath;
            pItem->IsActive = pItemArray[i].bActive;
            pItem->NativeDataType = VT_R4;
            pItem->RequestedDataType = pItemArray[i].vtRequestedDataType;
            pItem->Value = 0.0;
            pItem->Quality = OPC_QUALITY_UNCERTAIN;
            GetSystemTime(&SystemTime);        // Get current UTC Time
            SystemTimeToFileTime(&SystemTime, &(pItem->TimeStamp)); // and store it
            pItem->ClientHandle = pItemArray[i].hClient;
            // Server Handle will be assigned by Group
            pGroup->AddItem(pItem);

            // Set ITEM RESULT
            ir->hServer = pItem->SvrHandle;
            ir->vtCanonicalDataType = pItem->NativeDataType;
            ir->dwAccessRights = OPC_WRITEABLE | OPC_READABLE;
            ir->pBlob = NULL;
            ir->dwBlobSize = 0;
            }

        }

    for (i=0; i<dwNumItems; i++)
        {
        if (hr[i] != S_OK)
            return (E_FAIL);    // Some Items could not be added
        }
    
    return (S_OK);

}

int SomeObj::get_val()
{
    int val = 0;
    // делаем полезную работу, при ошибке выкидываем исключения
    return val;
}

//...

try
{
    int val = obj->get_val();
}
catch(...)
{
    std::cerr << "Произошла ошибка" << std::endl;
}

ErrCode SomeObj::get_val(int *retVal)
{
    ErrCode code = ErrFail;
    if(retVal != 0)
    {
        int val = 0;
        // делаем полезную работу, при ошибке передаём управление на точку выхода
        retVal = val;
        code = ErrOk;
    }
    return code;
}

//...

int val;
ErrCode code = obj->get_val(&val);
if(code == ErrOk)
{
}
else
{
    std::cerr << "Произошла ошибка" << std::endl;
}

AC>Если в программе нет шаблонов и исключений — это С с классами. Язык пионэров? Мачто на нем непушут, да?

main()
{
    asm
    {
        ...
    }
}

ErrCode SomeObj::get_val(int &retVal)
{
    // делаем полезную работу, при ошибке делаем return <код ошибки>
    retVal = ...;
        
    return ErrOk;
}

//...

int val;

if( ErrCode code = obj->get_val(val) )
{
 std::cerr << "Произошла ошибка " << GetErrorDescription(code) << std::endl;
}
else
{
}