<< Пред.           стр. 50 (из 121)           След. >>

Список литературы по разделу

  while ( min( array[++lo], elem ) != elem && lo < high ) ;
  while ( min( array[--hi], elem ) == elem && hi > low ) ;
 
  if (lo < hi)
  swap( array, lo, hi );
  else break;
  }
 
  swap( array, low, hi );
  sort( array, low, hi-1 );
  sort( array, hi+1, high );
  }
 }
 В sort() используются две вспомогательные функции: min() и swap(). Обе они должны определяться как шаблоны, чтобы иметь возможность обрабатывать любые типы фактических аргументов, с которыми может быть конкретизирован шаблон sort(). min() определена как шаблон функции для поиска минимального из двух значений любого типа:
 template
  Type min( Type a, Type b ) {
  return a < b ? a : b;
 }
 swap() – шаблон функции для перестановки двух элементов массива любого типа:
 template
  void swap( Array &array, int i, int j )
 {
  elemType tmp = array[ i ];
  array[ i ] = array[ j ];
  array[ j ] = tmp;
 }
 Убедиться в том, что функция sort() действительно работает, можно с помощью отображения содержимого массива после сортировки. Поскольку функция display() должна обрабатывать любой массив, конкретизированный из шаблона класса Array, ее тоже следует определить как шаблон:
 #include
 
 template
  void display( Array &array )
 { //формат отображения: < 0 1 2 3 4 5 >
 
  cout << "< ";
  for ( int ix = 0; ix < array.size(); ++ix )
  cout << array[ix] << " ";
  cout << ">\n";
 }
 В этом примере мы пользуемся моделью компиляции с включением и помещаем шаблоны всех функций в заголовочный файл Array.h вслед за объявлением шаблона класса Array.
 Следующий шаг – написание функции для тестирования этих шаблонов. В sort() поочередно передаются массивы элементов типа double, типа int и массив строк. Вот текст программы:
 #include
 #include
 #include "Array.h"
 
 double da[10] = {
  26.7, 5.7, 37.7, 1.7, 61.7, 11.7, 59.7,
  15.7, 48.7, 19.7 };
 
 int ia[16] = {
  503, 87, 512, 61, 908, 170, 897, 275, 653,
  426, 154, 509, 612, 677, 765, 703 };
 
 string sa[11] = {
  "a", "heavy", "snow", "was", "falling", "when",
  "they", "left", "the", "police", "station" };
 
 int main() {
 
  // вызвать конструктор для инициализации arrd
  Array arrd( da, sizeof(da)/sizeof(da[0]) );
 
  // вызвать конструктор для инициализации arri
  Array arri( ia, sizeof(ia)/sizeof(ia[0]) );
 
  // вызвать конструктор для инициализации arrs
  Array arrs( sa, sizeof(sa)/sizeof(sa[0]) );
 
  cout << "sort array of doubles (size == "
  << arrd.size() << ")" << endl;
  sort(arrd, 0, arrd.size()-1 );
  display(arrd);
 
  cout << "sort array of ints (size == "
  << arri.size() << ")" << endl;
  sort(arri, 0, arri.size()-1 );
  display(arri);
 
  cout << "sort array of strings (size == "
  << arrs.size() << ")" << endl;
  sort(arrs, 0, arrs.size()-1 );
  display(arrs);
 
  return 0;
 }
 Если скомпилировать и запустить программу, то она напечатает следующее (эти строки искусственно разбиты на небольшие части):
 
 sort array of doubles (size == 10)
 < 1.7 5.7 11.7 14.9 15.7 19.7 26.7
  37.7 48.7 59.7 61.7 >
 
 sort array of ints (size == 16)
 < 61 87 154 170 275 426 503 509 512
  612 653 677 703 765 897 908 >
 
 sort array of strings (size == 11)
 < "a" "falling" "heavy" "left" "police" "snow"
  "station" "the" "they" "was" "when" >
 
 В числе обобщенных алгоритмов, имеющихся в стандартной библиотеке C++ (и в главе 12), вы найдете также функции min() и swap(). В главе 12 мы покажем, как их использовать.
 11
 11. Обработка исключений
 Обработка исключений – это механизм, позволяющий двум независимо разработанным программным компонентам взаимодействовать в аномальной ситуации, называемой исключением. В этой главе мы расскажем, как генерировать, или возбуждать, исключение в том месте программы, где имеет место аномалия. Затем мы покажем, как связать catch-обработчик исключений с множеством инструкций программы, используя try-блок. Потом речь пойдет о спецификации исключений – механизме, с помощью которого можно связать список исключений с объявлением функции, и функция не сможет возбудить никаких других исключений. Закончится эта глава обсуждением решений, принимаемых при проектировании программы, в которой используются исключения.
 11.1. Возбуждение исключения
 Исключение – это аномальное поведение во время выполнения, которое программа может обнаружить, например: деление на 0, выход за границы массива или истощение свободной памяти. Такие исключения нарушают нормальный ход работы программы, и на них нужно немедленно отреагировать. В C++ имеются встроенные средства для их возбуждения и обработки. С помощью этих средств активизируется механизм, позволяющий двум несвязанным (или независимо разработанным) фрагментам программы обмениваться информацией об исключении.
 Когда встречается аномальная ситуация, та часть программы, которая ее обнаружила, может сгенерировать, или возбудить, исключение. Чтобы понять, как это происходит, реализуем по-новому класс iStack, представленный в разделе 4.15, используя исключения для извещения об ошибках при работе со стеком. Определение класса iStack выглядит следующим образом:
 #include
 class iStack {
 public:
  iStack( int capacity )
  : _stack( capacity ), _top( 0 ) { }
 
  bool pop( int &top_value );
  bool push( int value );
 
  bool full();
  bool empty();
  void display();
 
  int size();
 
 private:
  int _top;
  vector< int > _stack;
 };
 Стек реализован на основе вектора из элементов типа int. При создании объекта класса iStack его конструктор создает вектор из int, размер которого (максимальное число элементов, хранящихся в стеке) задается с помощью начального значения. Например, следующая инструкция создает объект myStack, который способен содержать не более 20 элементов типа int:
 iStack myStack(20);
 При манипуляциях с объектом myStack могут возникнуть две ошибки:
 запрашивается операция pop(), но стек пуст;
 запрашивается операция push(), но стек полон.
 Вызвавшую функцию нужно уведомить об этих ошибках посредством исключений. С чего же начать?
 Во-первых, мы должны определить, какие именно исключения могут быть возбуждены. В C++ они чаще всего реализуются с помощью классов. Хотя в полном объеме классы будут представлены в главе 13, мы все же определим здесь два из них, чтобы использовать их как исключения для класса iStack. Эти определения мы поместим в заголовочный файл stackExcp.h:
 // stackExcp.h
 class popOnEmpty { /* ... */ };
 class pushOnFull { /* ... */ };
 В главе 19 исключения в виде классов обсуждаются более подробно, там же рассматривается иерархия таких классов, предоставляемая стандартной библиотекой C++.
 Затем надо изменить определения функций-членов pop() и push() так, чтобы они возбуждали эти исключения. Для этого предназначена инструкция throw, которая во многих отношениях напоминает return. Она состоит из ключевого слова throw, за которым следует выражение того же типа, что и тип возбуждаемого исключения. Как выглядит инструкция throw для функции pop()? Попробуем такой вариант:
 // увы, это не совсем правильно
 throw popOnEmpty;
 К сожалению, так нельзя. Исключение – это объект, и функция pop() должна генерировать объект класса соответствующего типа. Выражение в инструкции throw не может быть просто типом. Для создания нужного объекта необходимо вызвать конструктор класса. Инструкция throw для функции pop() будет выглядеть так:
 // инструкция является вызовом конструктора
 throw popOnEmpty();
 Эта инструкция создает объект исключения типа popOnEmpty.
 Напомним, что функции-члены pop() и push() были определены как возвращающие значение типа bool: true означало, что операция завершилась успешно, а false – что произошла ошибка. Поскольку теперь для извещения о неудаче pop() и push() используют исключения, возвращать значение необязательно. Поэтому мы будем считать, что эти функции-члены имеют тип void:
 class iStack {
 public:
  // ...
 
  // больше не возвращают значения
  void pop( int &value );
  void push( int value );
 
 private:
  // ...
 };
 Теперь функции, пользующиеся нашим классом iStack, будут предполагать, что все хорошо, если только не возбуждено исключение; им больше не надо проверять возвращенное значение, чтобы узнать, как завершилась операция. В двух следующих разделах мы покажем, как определить функцию для обработки исключений, а сейчас представим новые реализации функций-членов pop() и push() класса iStack:
 #include "stackExcp.h"
 
 void iStack::pop( int &top_value )
 {
  if ( empty() )
  throw popOnEmpty();
 
  top_value = _stack[ --_top ];
 
  cout << "iStack::pop(): " << top_value << endl;
 }
 
 void iStack::push( int value )
 {
  cout << "iStack::push( " << value << " )\n";
 
  if ( full() )
  throw pushOnFull( value );
 
  _stack[ _top++ ] = value;
 }
 Хотя исключения чаще всего представляют собой объекты типа класса, инструкция throw может генерировать объекты любого типа. Например, функция mathFunc() в следующем примере возбуждает исключение в виде объекта-перечисления . Это корректный код C++:
 enum EHstate { noErr, zeroOp, negativeOp, severeError };
 
 int mathFunc( int i ) {
  if ( i == 0 )
  throw zeroOp; // исключение в виде объекта-перечисления
 
  // в противном случае продолжается нормальная обработка
 }
 Упражнение 11.1
 Какие из приведенных инструкций throw ошибочны? Почему? Для правильных инструкций укажите тип возбужденного исключения:
 (a) class exceptionType { };
  throw exceptionType();
 (b) int excpObj;
  throw excpObj;
 (c) enum mathErr { overflow, underflow, zeroDivide };
  throw mathErr zeroDivide();
 (d) int *pi = excpObj;
  throw pi;
 Упражнение 11.2
 У класса IntArray, определенного в разделе 2.3, имеется функция-оператор operator[](), в которой используется assert() для извещения о том, что индекс вышел за пределы массива. Измените определение этого оператора так, чтобы в подобной ситуации он генерировал исключение. Определите класс, который будет употребляться как тип возбужденного исключения.
 11.2. try-блок
 В нашей программе тестируется определенный в предыдущем разделе класс iStack и его функции-члены pop() и push(). Выполняется 50 итераций цикла for. На каждой итерации в стек помещается значение, кратное 3: 3, 6, 9 и т.д. Если значение кратно 4 (4, 8, 12...), то выводится текущее содержимое стека, а если кратно 10 (10, 20, 30...), то с вершины снимается один элемент, после чего содержимое стека выводится снова. Как нужно изменить функцию main(), чтобы она обрабатывала исключения, возбуждаемые функциями-членами класса iStack?
 #include
 #include "iStack.h"
 
 int main() {
  iStack stack( 32 );
 
  stack.display();
  for ( int ix = 1; ix < 51; ++ix )
  {
  if ( ix % 3 == 0 )
  stack.push( ix );
 
  if ( ix % 4 == 0 )
  stack.display();
 
  if ( ix % 10 == 0 ) {
  int dummy;
  stack.pop( dummy );
  stack.display();
  }
  }
  return 0;
 }
 Инструкции, которые могут возбуждать исключения, должны быть заключены в try-блок. Такой блок начинается с ключевого слова try, за которым идет последовательность инструкций, заключенная в фигурные скобки, а после этого – список обработчиков, называемых catch-предложениями. Try-блок группирует инструкции программы и ассоциирует с ними обработчики исключений. Куда нужно поместить try-блоки в функции main(), чтобы были обработаны исключения popOnEmpty и pushOnFull?
 for ( int ix = 1; ix < 51; ++ix ) {
  try { // try-блок для исключений pushOnFull
  if ( ix % 3 == 0 )
  stack.push( ix );
  }
  catch ( pusOnFull ) { ... }
 
  if ( ix % 4 == 0 )
  stack.display();
 
  try { // try-блок для исключений popOnEmpty
  if ( ix % 10 == 0 ) {
  int dummy;
  stack.pop( dummy );
  stack.display();
  }
  }
  catch ( popOnEmpty ) { ... }
 }
 В таком виде программа выполняется корректно. Однако обработка исключений в ней перемежается с кодом, использующимся при нормальных обстоятельствах, а такая организация несовершенна. В конце концов, исключения – это аномальные ситуации, возникающие только в особых случаях. Желательно отделить код для обработки аномалий от кода, реализующего операции со стеком. Мы полагаем, что показанная ниже схема облегчает чтение и сопровождение программы:
 try {
  for ( int ix = 1; ix < 51; ++ix )
  {
  if ( ix % 3 == 0 )
  stack.push( ix );
 
  if ( ix % 4 == 0 )
  stack.display();
 
  if ( ix % 10 == 0 ) {
  int dummy;
  stack.pop( dummy );
  stack.display();
  }
  }
 }
 catch ( pushOnFull ) { ... }
 catch ( popOnEmpty ) { ... }
 С try-блоком ассоциированы два catch-предложения, которые могут обработать исключения pushOnFull и popOnEmpty, возбуждаемые функциями-членами push() и pop() внутри этого блока. Каждый catch-обработчик определяет тип “своего” исключения. Код для обработки исключения помещается внутрь составной инструкции (между фигурными скобками), которая является частью catch-обработчика. (Подробнее catch-предложения мы рассмотрим в следующем разделе.)
 Исполнение программы может пойти по одному из следующих путей:
 если исключение не возбуждено, то выполняется код внутри try-блока, а ассоциированные с ним обработчики игнорируются. Функция main() возвращает 0;
 если функция-член push(), вызванная из первой инструкции if внутри цикла for, возбуждает исключение, то вторая и третья инструкции if игнорируются, управление покидает цикл for и try-блок, и выполняется обработчик исключений типа pushOnFull;
 если функция-член pop(), вызванная из третьей инструкции if внутри цикла for, возбуждает исключение, то вызов display() игнорируется, управление покидает цикл for и try-блок, и выполняется обработчик исключений типа popOnEmpty.
 Когда возбуждается исключение, пропускаются все инструкции, следующие за той, где оно было возбуждено. Исполнение программы возобновляется в catch-обработчике этого исключения. Если такого обработчика не существует, то управление передается в функцию terminate(), определенную в стандартной библиотеке C++.
 Try-блок может содержать любую инструкцию языка C++: как выражения, так и объявления. Он вводит локальную область видимости, так что объявленные внутри него переменные недоступны вне этого блока, в том числе и в catch-обработчиках. Например, функцию main() можно переписать так, что объявление переменной stack окажется в try-блоке. В таком случае обращаться к этой переменной в catch-обработчиках нельзя:
 int main() {
  try {
  iStack stack( 32 ); // правильно: объявление внутри try-блока
 
  stack.display();
  for ( int ix = 1; ix < 51; ++ix )
  {
  // то же, что и раньше
  }
  }
  catch ( pushOnFull ) {
  // здесь к переменной stack обращаться нельзя
  }
  catch ( popOnEmpty ) {
  // здесь к переменной stack обращаться нельзя
  }
 
  // и здесь к переменной stack обращаться нельзя
  return 0;
 }
 Можно объявить функцию так, что все ее тело будет заключено в try-блок. При этом не обязательно помещать try-блок внутрь определения функции, удобнее заключить ее тело в функциональный try-блок. Такая организация поддерживает наиболее чистое разделение кода для нормальной обработки и кода для обработки исключений. Например:
 int main()
  try {
  iStack stack( 32 ); // правильно: объявление внутри try-блока
 
  stack.display();
  for ( int ix = 1; ix < 51; ++ix )
  {
  // то же, что и раньше
  }
 
  return 0;

<< Пред.           стр. 50 (из 121)           След. >>

Список литературы по разделу