Сделай Сам Свою Работу на 5

Объектно-ориентированный подход

Вспомним спецификацию нашего массива в предыдущем разделе. Мы говорили о том, что некоторым пользователям может понадобиться упорядоченный массив, в то время как большинство, скорее всего, удовлетворится и неупорядоченным. Если представить себе, что наш массив IntArray упорядочен, то реализация таких функций, как min(), max(), find(), должна отличаться от их реализации для массива неупорядоченного большей эффективностью. Вместе с тем, для поддержания массива в упорядоченном состоянии все прочие функции должны быть сильно усложнены.

Мы выбрали наиболее общий случай – неупорядоченный массив. Но как же быть с теми немногочисленными пользователями, которым обязательно нужна функциональность массива упорядоченного? Мы должны специально для них создать другой вариант массива?

А вот и еще одна категория недовольных пользователей: их не удовлетворяют накладные расходы на проверку правильности индекса. Мы исходили из того, что корректность работы нашего класса превыше всего, и старались обезопасить себя от ошибочных ситуаций. Но возьмем, к примеру, разработчиков систем виртуальной реальности. Трехмерные изображения должны строиться с максимально возможной скоростью, быть может, за счет точности.

Да, мы можем удовлетворить и тех и других, создав для каждой группы пользователей свой, немного модернизированный, вариант IntArray. Более того, его даже не слишком трудно сделать, поскольку мы старались создать хорошую реализацию и необходимые изменения затронут совсем небольшие участки кода. Итак, копируем исходный текст, вносим необходимые изменения в нужные места и получаем три класса:

// неупорядоченный массив без проверки границ индекса class IntArray { ... };   // неупорядоченный массив с проверкой границ индекса class IntArrayRC { ... };   // упорядоченный массив без проверки границ индекса

class IntSortedArray { ... };

Подобное решение имеет следующие недостатки:

· нам необходимо сопровождать три копии кода, различающиеся весьма незначительно. Хорошо бы выделить общие участки кода. Кроме упрощения сопровождения, это позволит использовать их впоследствии, если мы захотим создать еще один вариант массива, например упорядоченный с проверкой границ индекса;



· если понадобится какая-то общая функция для обработки всех наших массивов, то нам придется написать три копии, поскольку типы ее параметров будут различаться:

void process_array (IntArray&); void process_array (IntArrayRC&);

void process_array (IntSortedArray&);

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

Парадигма объектно-ориентированного программирования позволяет осуществить все эти пожелания. Механизм наследования обеспечивает пожелания из первого пункта. Если один класс является потомком другого (например, IntArrayRC потомок класса IntArray), то наследник имеет возможность пользоваться всеми данными и функциями-членами, определенными в классе-предке. То есть класс IntArrayRC может просто использовать всю основную функциональность, предоставляемую классом IntArray, и добавить только то, что нужно ему для обеспечения проверки границ индекса.

В С++ класс, свойства которого наследуются, называют также базовым классом, а класс-наследник – производным классом, или подклассом базового. Класс и подкласс имеют общий интерфейс, предоставляемый базовым классом (т.к. подкласс имеет все функции-члены базового класса). Значит, программу, использующую только функции из этого общего интерфейса, не должен интересовать фактический тип объекта, с которым она работает, – базового ли типа этот объект или производного. В этом смысле общий интерфейс скрывает специфичные для подкласса детали. Отношения между классами и подклассами называются иерархией наследования классов. Вот как может выглядеть реализация функции swap(), которая меняет местами два указанных элемента массива. Первым параметром функции является ссылка на базовый класс IntArray:

#include <IntArray.h>   void swap (IntArray &ia, int i, int j) { int temp ia[i]; ia[i] = ia[j]; ia[j] = temp; }   // ниже идут обращения к функции swap: IntArray ia; IntArrayRC iarc; IntSortedArray ias; // правильно - ia имеет тип IntArray swap (ia,0,10);   // правильно - iarc является подклассом IntArray swap (iarc,0,10);   // правильно - ias является подклассом IntArray swap (ias,0,10);  

// ошибка - string не является подклассом IntArray

string str("Это не IntArray!");

swap (str,0,10);

Каждый из трех классов реализует операцию взятия индекса по-своему. Поэтому важно, чтобы внутри функции swap() вызывалась нужная операция взятия индекса. Так, если swap() вызвана для IntArrayRC:

swap (iarc,0,10);

то должна вызываться функция взятия индекса для объекта класса IntArrayRC, а для

swap (ias,0,10);

функция взятия индекса IntSortedArray. Именно это и обеспечивает механизм виртуальных функций С++.

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

При простом объектном подходе можно выделить двух разработчиков конечной программы – разработчик класса и пользователь класса (тот, кто использует данный класс в конечной программе), причем последний обращается только к открытому интерфейсу. Для такого случая достаточно двух уровней доступа к членам класса – открытого (public) и закрытого (private).

Если используется наследование, то к этим двум группам разработчиков добавляется третья, промежуточная. Производный класс может проектировать совсем не тот человек, который проектировал базовый, и для того чтобы реализовать класс-наследник, совсем не обязательно иметь доступ к реализации базового. И хотя такой доступ может потребоваться при проектировании подкласса, от конечного пользователя обоих классов эта часть по-прежнему должна быть закрыта. К двум уровням доступа добавляется третий, в некотором смысле промежуточный, – защищенный (protected). Члены класса, объявленные как защищенные, могут использоваться классами-потомками, но никем больше. (Закрытые члены класса недоступны даже для его потомков.)

Вот как выглядит модифицированное описание класса IntArray:

class IntArray { public: // конструкторы explicit IntArray (int sz = DefaultArraySize); IntArray (int *array, int array_size); IntArray (const IntArray &rhs);   // виртуальный деструктор virtual ~IntArray() { delete[] ia; }   // операции сравнения: bool operator== (const IntArray&) const; bool operator!= (const IntArray&) const;   // операция присваивания: IntArray& operator= (const IntArray&); int size() const { return _size; };   // мы убрали проверку индекса...

virtual int& operator[](int index)

{ return ia[index]; }

virtual void sort();

 

virtual int min() const;

virtual int max() const;

virtual int find (int value) const;

 

protected:

static const int DefaultArraySize = 12;

void init (int sz; int *array);

 

int _size;

int *ia;

}

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

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

Теперь нам необходимо определить, реализация каких функций-членов базового класса может меняться в подклассах. Такие функции мы объявим виртуальными. Как уже отмечалось выше, реализация операции взятия индекса будет отличаться по крайней мере для подкласса IntArrayRC. Реализация операторов сравнения и функции size() одинакова для всех подклассов, следовательно, они не будут виртуальными.

При вызове невиртуальной функции компилятор определяет все необходимое еще на этапе компиляции. Если же он встречает вызов виртуальной функции, то не пытается сделать этого. Выбор нужной из набора виртуальных функций (разрешение вызова) происходит во время выполнения программы и основывается на типе объекта, из которого она вызвана. Рассмотрим пример:

void init (IntArray &ia)

{

for (int ix=0; ix<ia.size(); ++ix)

ia[ix] = ix;

}

Формальный параметр функции ia может быть ссылкой на IntArray, IntArrayRC или на IntSortedArray. Функция-член size() не является виртуальной и разрешается на этапе компиляции. А вот виртуальный оператор взятия индекса не может быть разрешен на данном этапе, поскольку реальный тип объекта, на который ссылается ia, в этот момент неизвестен.

(В главе 17 мы будем говорить о виртуальных функциях более подробно. Там мы рассмотрим также и накладные расходы, которые влечет за собой их использование.)

Вот как выглядит определение производного класса IntArrayRC:

#ifndef IntArrayRC_H #define IntArrayRC_H   #include "IntArray.h"   class IntArrayRC : public IntArray { public: IntArrayRC( int sz = DefaultArraySize ); IntArrayRC( const int *array, int array_size ); IntArrayRC( const IntArrayRC &rhs );   virtual int& operator[]( int ) const;   private: void check_range( int ix ); };

#endif

Этот текст мы поместим в заголовочный файл IntArrayRC.h. Обратите внимание на то, что в наш файл включен заголовочный файл IntArray.h.

В классе IntArrayRC мы должны реализовать только те особенности, которые отличают его от IntArray: класс IntArrayRC должен иметь свою собственную реализацию операции взятия индекса; функцию для проверки индекса и собственный набор конструкторов.

Все данные и функции-члены класса IntArray можно использовать в классе IntArrayRC так, как будто это его собственные члены. В этом и заключается смысл наследования. Синтаксически наследование выражается строкой

class IntArrayRC : public IntArray

Эта строка показывает, что класс IntArrayRC произведен от класса IntArray, другими словами, наследует ему. Ключевое слово public в данном контексте говорит о том, что производный класс сохраняет открытый интерфейс базового класса, то есть что все открытые функции базового класса остаются открытыми и в производном. Объект типа IntArrayRC может использоваться вместо объекта типа IntArray, как, например, в приведенном выше примере с функцией swap(). Таким образом, подкласс IntArrayRC – это расширенная версия класса IntArray.

Вот как выглядит реализация операции взятия индекса:

IntArrayRC::operator[]( int index ) { check_range( index ); return _ia[ index ];

}

А вот реализация встроенной функции check_range():

#include <cassert>   inline void IntArrayRC::check_range(int index) { assert (index>=0 && index < _size);

}

(Мы говорили о макросе assert() в разделе 1.3.)

Почему проверка индекса вынесена в отдельную функцию, а не выполняется прямо в теле оператора взятия индекса? Потому что, если мы когда-нибудь потом захотим изменить что-то в реализации проверки, например написать свою обработку ошибок, а не использовать assert(), это будет сделать проще.

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

Однако заметим, что в нашем производном классе IntArrayRC нет новых членов, представляющих данные. Значит ли это, что нам не нужно реализовывать конструкторы для него? Ведь вся работа по инициализации членов данных уже проделана конструкторами базового класса.

На самом деле конструкторы, как и деструкторы или операторы присваивания, не наследуются – это правило языка С++. Кроме того, конструктор производного класса обеспечивает механизм передачи параметров конструктору базового класса. Рассмотрим пример. Пусть мы хотим создать объект класса IntArrayRC следующим образом:

int ia[] = {0,1,1,2,3,5,8,13};

IntArrayRC iarc(ia,8);

Нам нужно передать параметры ia и 8 конструктору базового класса IntArray. Для этого служит специальная синтаксическая конструкция. Вот как выглядят реализации двух конструкторов IntArrayRC:

inline IntArrayRC::IntArrayRC( int sz ) : IntArray( sz ) {}   inline IntArrayRC::IntArrayRC( const int *iar, int sz )

: IntArray( iar, sz ) {}

(Мы будем подробно говорить о конструкторах в главах 14 и 17. Там же мы покажем, почему не нужно реализовывать конструктор копирования для IntArrayRC.)

Часть определения, следующая за двоеточием, называется списком инициализации членов. Именно здесь, указав конструктор базового класса, мы можем передать ему параметры. Тела обоих конструкторов пусты, поскольку их работа состоит исключительно в передаче параметров конструктору базового класса. Нам не нужно реализовывать деструктор для IntArrayRC, так как ему просто нечего делать. Точно так же, как при создании объекта производного типа вызывается сначала конструктор базового типа, а затем производного, при уничтожении автоматически вызываются деструкторы – естественно, в обратном порядке: сначала деструктор производного, затем базового. Таким образом, деструктор базового класса будет вызван для объекта типа IntArrayRC, хотя тот и не имеет собственной аналогичной функции.

Мы поместим все встроенные функции класса IntArrayRC в тот же заголовочный файл IntArrayRC.h. Поскольку у нас нет невстроенных функций, то создавать файл IntArrayRC.C не нужно.

Вот пример простой программы, использующей классы IntArray и IntArrayRC:

#include <iostream> #include "IntArray.h" #include "IntArrayRC.h"   void swap( IntArray &ia, int ix, int jx ) { int tmp = ia[ ix ]; ia[ ix ] = ia[ jx ]; ia[ jx ] = tmp; }   int main() { int array[ 4 ] = { 0, 1, 2, 3 }; IntArray ia1( array, 4 ); IntArrayRC ia2( array, 4 );   // ошибка: должно быть size-1 // не может быть выявлена объектом IntArray cout << "swap() with IntArray ia1" << endl; swap( ia1, 1, ia1.size() );   // правильно: объект IntArrayRC "поймает" ошибку cout << "swap() with IntArrayRC ia2" << endl; swap( ia2, 1, ia2.size() ); return 0;

}

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

 

swap() with IntArray ia1

swap() with IntArrayRC ia2

Assertion failed: ix >= 0 && ix < _size,

file IntArrayRC.h, line 19

 

Упражнение 2.8

Отношение наследования между типом и подтипом служит примером отношения является. Так, массив IntArrayRC является подвидом массива IntArray, книга является подвидом выдаваемых библиотекой предметов, аудиокнига является подвидом книги и т.д. Какие из следующих утверждений верны?

(a) функция-член является подвидом функции (b) функция-член является подвидом класса (c) конструктор является подвидом функции-члена (d) самолет является подвидом транспортного средства (e) машина является подвидом грузовика (f) круг является подвидом геометрической фигуры (g) квадрат является подвидом треугольника (h) автомобиль является подвидом самолета

(i) читатель является подвидом библиотеки

Упражнение 2.9

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

(a) rotate(); (b) print(); (c) size(); (d) DateBorrowed(); // дата выдачи книги (e) rewind(); (f) borrower(); // читатель (g) is_late(); // книга просрочена

(h) is_on_loan(); // книга выдана

Упражнение 2.10

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

Упражнение 2.11

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

Упражнение 2.12

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

(a) Точка (b) Служащий (c) Фигура (d) Телефонный_номер (e) Счет_в_банке

(f) Курс_продажи

Использование шаблонов

Наш класс IntArray служит хорошей альтернативой встроенному массиву целых чисел. Но в жизни могут потребоваться массивы для самых разных типов данных. Можно предположить, что единственным отличием массива элементов типа double от нашего является тип данных в объявлениях, весь остальной код совпадает буквально.

Для решения данной проблемы в С++ введен механизм шаблонов. В объявлениях классов и функций допускается использование параметризованных типов. Типы-параметры заменяются в процессе компиляции настоящими типами, встроенными или определенными пользователем. Мы можем создать шаблон класса Array, заменив в классе IntArray тип элементов int на обобщенный тип-параметр. Позже мы конкретизируем типы-параметры, подставляя вместо них реальные типы int, double и string. В результате появится способ использовать эти конкретизации так, как будто мы на самом деле определили три разных класса для этих трех типов данных.

Вот как может выглядеть шаблон класса Array:

template <class elemType> class Array { public: explicit Array( int sz = DefaultArraySize ); Array( const elemType *ar, int sz ); Array( const Array &iA );   virtual ~Array() { delete[] _ia; }   Array& operator=( const Array & ); int size() const { return _size; }   virtual elemType& operator[]( int ix ) { return _ia[ix]; }   virtual void sort( int,int ); virtual int find( const elemType& ); virtual elemType min(); virtual elemType max(); protected: void init( const elemType*, int ); void swap( int, int ); static const int DefaultArraySize = 12; int _size; elemType *_ia;

};

Ключевое слово template говорит о том, что задается шаблон, параметры которого заключаются в угловые скобки (<>). В нашем случае имеется лишь один параметр elemType; ключевое слово class перед его именем сообщает, что этот параметр представляет собой тип.

При конкретизации класса-шаблона Array параметр elemType заменяется на реальный тип при каждом использовании, как показано в примере:

#include <iostream> #include "Array.h"   int main() { const int array_size = 4;   // elemType заменяется на int Array<int> ia(array_size);   // elemType заменяется на double Array<double> da(array_size);   // elemType заменяется на char Array<char> ca(array_size);   int ix;   for ( ix = 0; ix < array_size; ++ix ) { ia[ix] = ix; da[ix] = ix * 1.75; ca[ix] = ix + 'a'; }   for ( ix = 0; ix < array_size; ++ix ) cout << "[ " << ix << " ] ia: " << ia[ix] << "\tca: " << ca[ix] << "\tda: " << da[ix] << endl;   return 0;

}

Здесь определены три экземпляра класса Array:

Array<int> ia(array_size);

Array<double> da(array_size);

Array<char> ca(array_size);

Что делает компилятор, встретив такое объявление? Подставляет текст шаблона Array, заменяя параметр elemType на тот тип, который указан в каждом конкретном случае. Следовательно, объявления членов приобретают в первом случае такой вид:

// Array<int> ia(array_size);

int _size;

int *_ia;

Заметим, что это в точности соответствует определению массива IntArray.

Для оставшихся двух случаев мы получим следующий код:

// Array<double> da(array_size);

int _size;

double *_ia;

 

// Array<char> ca(array_size);

int _size;

char *_ia;

Что происходит с функциями-членами? В них тоже тип-параметр elemType заменяется на реальный тип, однако компилятор не конкретизирует те функции, которые не вызываются в каком-либо месте программы. (Подробнее об этом в разделе 16.8.)

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

 

[ 0 ] ia: 0 ca: a da: 0

[ 1 ] ia: 1 ca: b da: 1.75

[ 2 ] ia: 2 ca: c da: 3.5

[ 3 ] ia: 3 ca: d da: 5.25

 

Механизм шаблонов можно использовать и в наследуемых классах. Вот как выглядит определение шаблона класса ArrayRC:

#include <cassert>

#include "Array.h"

 

template <class elemType>

class ArrayRC : public Array<elemType> {

public:

ArrayRC( int sz = DefaultArraySize )

: Array<elemType>( sz ) {}

ArrayRC( const ArrayRC& r )

: Array<elemType>( r ) {}

ArrayRC( const elemType *ar, int sz )

: Array<elemType>( ar, sz ) {}

 

elemType& ArrayRC<elemType>::operator[]( int ix )

{

assert( ix >= 0 && ix < Array<elemType>::_size );

return _ia[ ix ];

}

private:

// ...

};

Подстановка реальных параметров вместо типа-параметра elemType происходит как в базовом, так и в производном классах. Определение

ArrayRC<int> ia_rc(10);

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

// функцию swap() тоже следует сделать шаблоном

swap( ia1, 1, ia1.size() );

был допустимым, нам потребуется представить функцию swap() в виде шаблона.

#include "Array.h"

 

template <class elemType>

inline void

swap( Array<elemType> &array, int i, int j )

{

elemType tmp = array[ i ];

array[ i ] = array[ j ];

array[ j ] = tmp;

}

При каждом вызове swap() генерируется подходящая конкретизация, которая зависит от типа массива. Вот как выглядит программа, использующая шаблоны Array и ArrayRC:

#include <iostream>

#include "Array.h"

#include "ArrayRC.h"

 

template <class elemType>

inline void

swap( Array<elemType> &array, int i, int j )

{

elemType tmp = array[ i ];

array[ i ] = array[ j ];

array[ j ] = tmp;

}

 

int main()

{

Array<int> ia1;

ArrayRC<int> ia2;

 

cout << "swap() with Array<int> ia1" << endl;

int size = ia1.size();

swap( ia1, 1, size );

 

cout << "swap() with ArrayRC<int> ia2" << endl;

size = ia2.size();

swap( ia2, 1, size );

 

return 0;

}

Упражнение 2.13

Пусть мы имеем следующие объявления типов:

template<class elemType> class Array;

enum Status { ... };

typedef string *Pstring;

Есть ли ошибки в приведенных ниже описаниях объектов?

(a) Array< int*& > pri(1024); (b) Array< Array<int> > aai(1024); (c) Array< complex< double > > acd(1024); (d) Array< Status > as(1024);

(e) Array< Pstring > aps(1024);

Упражнение 2.14

Перепишите следующее определение, сделав из него шаблон класса:

class example1 { public: example1 (double min, double max); example1 (const double *array, int size);   double& operator[] (int index); bool operator== (const example1&) const;   bool insert (const double*, int); bool insert (double);   double min (double) const { return _min; }; double max (double) const { return _max; };   void min (double); void max (double);   int count (double value) const;   private: int size; double *parray; double _min; double _max;

}

Упражнение 2.15

Имеется следующий шаблон класса:

template <class elemType> class Example2 {

public:

explicit Example2 (elemType val=0) : _val(val) {};

 

bool min(elemType value) { return _val < value; }

void value(elemType new_val) { _val = new_val; }

void print (ostream &os) { os << _val; }

 

private:

elemType _val;

}

 

template <class elemType>

ostream& operator<<(ostream &os,const Example2<elemType> &ex)

{ ex.print(os); return os; }

Какие действия вызывают следующие инструкции?

(a) Example2<Array<int>*> ex1; (b) ex1.min (&ex1); (c) Example2<int> sa(1024),sb; (d) sa = sb; (e) Example2<string> exs("Walden");

(f) cout << "exs: " << exs << endl;

Упражнение 2.16

Пример из предыдущего упражнения накладывает определенные ограничения на типы данных, которые могут быть подставлены вместо elemType. Так, параметр конструктора имеет по умолчанию значение 0:

explicit Example2 (elemType val=0) : _val(val) {};

Однако не все типы могут быть инициализированы нулем (например, тип string), поэтому определение объекта

Example2<string> exs("Walden");

является правильным, а

Example2<string> exs2;

приведет к синтаксической ошибке[4]. Также ошибочным будет вызов функции min(), если для данного типа не определена операция меньше. С++ не позволяет задать ограничения для типов, подставляемых в шаблоны. Как вы думаете, было бы полезным иметь такую возможность? Если да, попробуйте придумать синтаксис задания ограничений и перепишите в нем определение класса Example2. Если нет, поясните почему.

Упражнение 2.17

Как было показано в предыдущем упражнении, попытка использовать шаблон Example2 с типом, для которого не определена операция меньше, приведет к синтаксической ошибке. Однако ошибка проявится только тогда, когда в тексте компилируемой программы действительно встретится вызов функции min(), в противном случае компиляция пройдет успешно. Как вы считаете, оправдано ли такое поведение? Не лучше ли предупредить об ошибке сразу, при обработке описания шаблона? Поясните свое мнение.

Использование исключений

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

С++ предоставляет стандартный способ реакции на исключения. Благодаря вынесению в отдельную часть программы кода, ответственного за проверку и обработку ошибок, значительно облегчается восприятие текста программы и сокращается ее размер. Единый синтаксис и стиль обработки исключений можно, тем не менее, приспособить к самым разнообразным нуждам и запросам.

Механизм исключений делится на две основные части:

точка программы, в которой произошло исключение. Определение того факта, что при выполнении возникла какая-либо ошибка, влечет за собой возбуждение исключения. Для этого в С++ предусмотрен специальный оператор throw. Возбуждение исключения в случае невозможности открыть некоторый файл выглядит следующим образом:

if ( !infile ) { string errMsg("Невозможно открыть файл: "); errMsg += fileName; throw errMsg;

}

Место программы, в котором исключение обрабатывается. При возбуждении исключения нормальное выполнение программы приостанавливается и управление передается обработчику исключения. Поиск нужного обработчика часто включает в себя раскрутку так называемого стека вызовов программы. После обработки исключения выполнение программы возобновляется, но не с того места, где произошло исключение, а с точки, следующей за обработчиком. Для определения обработчика исключения в С++ используется ключевое слово catch. Вот как может выглядеть обработчик для примера из предыдущего абзаца:

catch (string exceptionMsg) {

log_message (exceptionMsg);

return false;

}

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

int* stats (const int *ia, int size)

{

int *pstats = new int [4];

try {

pstats[0] = sum_it (ia,size);

pstats[1] = min_val (ia,size);

pstats[2] = max_val (ia,size);

}

catch (string exceptionMsg) {

// код обработчика

}

catch (const statsException &statsExcp) {

// код обработчика

}

 

pstats [3] = pstats[0] / size;

do_something (pstats);

 

return pstats;

}

В данном примере в теле функции stats() три оператора заключены в try-блок, а четыре – нет. Из этих четырех операторов два способны возбудить исключения.

1) int *pstats = new int [4];

Выполнение оператора new может окончиться неудачей. Стандартная библиотека С++ предусматривает возбуждение исключения bad_alloc в случае невозможности выделить нужное количество памяти. Поскольку в примере не предусмотрен обработчик исключения bad_alloc, при его возбуждении выполнение программы закончится аварийно.

2) do_something (pstats);

Мы не знаем реализации функции do_something(). Любая инструкция этой функции, или функции, вызванной из этой функции, или функции, вызванной из функции, вызванной этой функцией, и так далее, потенциально может возбудить исключение. Если в реализации функции do_something и вызываемых из нее предусмотрен обработчик такого исключения, то выполнение stats() продолжится обычным образом. Если же такого обработчика нет, выполнение программы аварийно завершится.

Необходимо заметить, что, хотя оператор

pstats [3] = pstats[0] / size;

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

Обратимся теперь к инструкциям, объединенным в try-блок. Если в одной из вызываемых в этом блоке функций – sum_it(), min_val() или max_val() –произойдет исключение, управление будет передано на обработчик, следующий за try-блоком и перехватывающий именно это исключение. Ни инструкция, возбудившая исключение, ни следующие за ней инструкции в try-блоке выполнены не будут. Представим себе, что при вызове функции sum_it() возбуждено исключение:

throw string ("Ошибка: adump27832");

Выполнение функции sum_it() прервется, операторы, следующие в try-блоке за вызовом этой функции, также не будут выполнены, и pstats[0] не будет инициализирована. Вместо этого возбуждается исключительное состояние и исследуются два catch-обработчика. В нашем случае выполняется catch с параметром типа string:

catch (string exceptionMsg) { // код обработчика

}

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

pstats [3] = pstats[0] / size;

(Конечно, обработчик сам может возбуждать исключения, в том числе – того же типа. В такой ситуации будет продолжено выполнение catch-предложений, определенных в программе, вызвавшей функцию stats().)

Вот пример:

catch (string exceptionMsg) {

// код обработчика

cerr << "stats(): исключение: "

<< exceptionMsg

<< endl;

delete [] pstats;

return 0;

}

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

Функция stats() умеет реагировать на два типа исключений: string и statsException. Исключение любого другого типа игнорируется, и управление передается в вызвавшую функцию, а если и в ней не найдется обработчика, – то в функцию более высокого уровня, и так до функции main().При отсутствии обработчика и там, программа аварийно завершится.

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

catch (...) { // обрабатывает любое исключение, // однако ему недоступен объект, переданный // в обработчик в инструкции throw

}

(Детально обработка исключительных ситуаций рассматривается в главах 11 и 19.)

Упражнение 2.18

Какие ошибочные ситуации могут возникнуть во время выполнения следующей функции:

int *alloc_and_init (string file_name)

{

ifstream infile (file_name)

int elem_cnt;

infile >> elem_cnt;

int *pi = allocate_array(elem_cnt);

 

int elem;

int index=0;

while (cin >> elem)

pi[index++] = elem;

 

sort_array(pi,elem_cnt);

register_data(pi);

 

return pi;

}

Упражнение 2.19

В предыдущем примере вызываемые функции allocate_array(), sort_array() и register_data() могут возбуждать исключения типов noMem, int и string соответственно. Перепишите функцию alloc_and_init(), вставив соответствующие блоки try и catch для обработки этих исключений. Пусть обработчики просто выводят в cerr сообщение об ошибке.

Упражнение 2.20

Усовершенствуйте функцию alloc_and_init() так, чтобы она сама возбуждала исключение в случае возникновения всех возможных ошибок (это могут быть исключения, относящиеся к вызываемым функциям allocate_array(), sort_array() и register_data() и какими-то еще операторами внутри функции alloc_and_init()). Пусть это исключение имеет тип string и строка, передаваемая обработчику, содержит описание ошибки.



©2015- 2019 stydopedia.ru Все материалы защищены законодательством РФ.