WWW.DISSERS.RU

БЕСПЛАТНАЯ ЭЛЕКТРОННАЯ БИБЛИОТЕКА

   Добро пожаловать!

Pages:     | 1 |   ...   | 2 | 3 ||

«ВЕРЕВКА ДОСТАТОЧНОЙ ДЛИНЫ, ЧТОБЫ… ВЫСТРЕЛИТЬ СЕБЕ В НОГУ Правила программирования на Си и Си++ Ален И. Голуб Москва 2001 Программисты, инженеры, научные работники, студенты и все, кто работает ...»

-- [ Страница 4 ] --

// вызывает some_class::operator delete() Помните, что эти две строки могут быть в различных файлах.

220 Правила программирования на Си++ Часть 8з. Шаблоны Многие проблемы с шаблонами в действительности вызваны учебниками, которые обычно настолько упрощенно рассматривают шаблоны, что вы заканчиваете чтение, не получив и намека на то, как они должны использоваться. Этот раздел посвящен распространенным затруднениям, связанным с шаблонами.

155. Используйте встроенные шаблоны функций вместо параметризированных макросов Приведенный ранее пример:

#define SQUARE(x) ((x) * (x)) где:

SQUARE(++x) расширяется до:

((++x)*(++x)) инкрементируя x дважды. Вы не можете решить эту проблему в Си, а в Си++ можете. Простая встроенная функция работает вполне удовлетворительно, в таком виде:

inline int square( int x ){ return x * x;

} не давая побочного эффекта. Тем не менее, она допускает лишь целочисленные аргументы. Шаблон функции, который расширяется во множество перегруженных встроенных функций, является более общим решением:

template inline type square( type x ){ return x * x;

} К несчастью, это срабатывает только в простых ситуациях. Следующий шаблон не может обработать вызов max(10, 10L), потому что не совпадают типы аргументов:

template inline type max( type x, type y ){ return (x > y) ? x : y;

} Для обработки max(10, 10L) вы должны использовать прототип, чтобы принудить к расширению по тому варианту max(), который может выполнить данную работу:

Шаблоны long max( long, long );

Прототип вызывает расширение шаблона. Компилятор с легкостью преобразует аргумент типа int в long, даже если ему не нужно делать это преобразование для расширения шаблона.

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

156. Всегда знайте размер шаблона после его расширения Большинство книг демонстрирует шаблоны типа простого контейнера массива, подобного показаному на листинге 13. Вы не можете использовать здесь наследование (скажем, с базовым классом array, от которого наследуется int_array). Проблема заключается в перегрузке операции operator[](). Вы бы хотели, чтобы она была виртуальной функцией в базовом классе, замещенная затем в производном классе, но сигнатура версии производного класса должна отличаться от сигнатуры базового класса, чтобы все это заработало. Здесь определения функций должны отличаться лишь возвращаемыми типами:

int_array::operator[]() должна возвращать ссылку на тип int, а long_array::operator[]() должна возвращать ссылку на тип long, и так далее. Так как время возврата не рассматривается как часть сигнатуры при выборе перегруженной функции, то реализация на основе наследования не жизнеспособна. Единственным решением является шаблон.

Листинг 13. Простой контейнер массива 1 template 2 class array 3 { 4 type array[size];

5 public:

6 class out_of_bounds {};

// возбуждается исключение, если 7// индекс за пределами массива 8 type &operator[](int index);

9 };

11 template 12 inline type &array::operator[](int index) 13 { 14 if( 0 <= index && index < size ) 15 return array[ index ] 222 Правила программирования на Си++ 16 throw out_of_bounds;

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

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

array ten_element_array;

array eleven_element_array;

array twelve_element_array;

array thirteen_element_array;

(то есть array::operator[](), array::operator []() и так далее).

Вопрос состоит в том, как сократить до минимума дублирование кода.

Что, если мы уберем размер за пределы шаблона, как на листинге 14?

Предыдущие объявления теперь выглядят так:

array ten_element_array (10);

array eleven_element_array (11);

array twelve_element_array (12);

array thirteen_element_array (13);

Теперь у нас есть только одно определение класса (и один вариант operator[]()) с четырьмя объектами этого класса.

Листинг 14. Шаблон массива (второй проход) 1 template 2 class array 3 { 4 type *array;

5 int size;

6 public:

7 virtual ~array( void );

8 array( int size = 128 );

10 class out_of_bounds {};

// возбуждается исключение, если 11 // индекс за пределами массива 12 type &operator[](int index);

13 };

Функции из шаблонов генерируется, только если они используются в программе (по крайней мере, так должен поступать хороший компилятор). — Ред.

Шаблоны 15 template 16 array::array( int sz /*= 128*/ ): size(sz) 17, array( new type[ sz ] ) 18 {} 20 template 21 array::~array( void ) 22 { 23 delete [] array;

24 } 26 template 27 inline type &array::operator[](int index) 28 { 29 if( 0 <= index && index < size ) 30 return array[ index ] 31 throw out_of_bounds;

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

array< array, 20> ar;

(20-элементный массив из 10-элементных массивов). Определение на листинге 14 устанавливает размер массива, используя конструктор, поэтому лучшее, что вы можете получить, это:

array< array > ar2(20);

Внутренний array создан с использованием конструктора по умолчанию, поэтому это 128-элементный массив;

мы объявили 20 элементный массив из 128-элементных массивов.

Вы можете решить эту последнюю проблему при помощи наследования. Рассмотрим следующее определение производного класса:

template< class type, int size > class sized_array : public array { public:

sized_array() : array(size) {} };

Здесь ничего нет, кроме единственной встроенной функции, поэтому это определение очень маленького класса. Оно совсем не будет увеличивать размер программы, вне зависимости от того, сколько раз будет расширен шаблон. Вы теперь можете записать:

sized_array< sized_array, 20> ar3;

224 Правила программирования на Си++ для того, чтобы получить 20-элементный массив из 10-элементных массивов.

157. Шаблоны классов должны обычно определять производные классы 158. Шаблоны не заменяют наследование;

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

Во-первых, давайте взглянем на то, что не нужно делать. Класс storable, уже использованный мной, снова представляется хорошим примером. Сначала создадим объект collection для управления сохраняемыми объектами:

class collection { storable *head;

public:

//...

storable *find( const storable &a_match_of_this ) const;

};

storable *collection::find( const storable &a_match_of_this ) const { // Послать сообщение объекту начала списка, указывающее, что спи– // сок просматривается на совпадение со значением a_match_of_this;

return head ? head->find( a_match_of_this ) : NULL ;

} Механизм поиска нужных объектов скрыт внутри класса storable. Вы можете изменить лежащую в основе структуру данных, поменяв определение storable, и эти изменения совсем не затронут реализацию класса collection.

Затем давайте реализуем класс storable, использующий простой связанный список в качестве лежащей в основе структуры данных:

class storable { storable *next, *prev;

Шаблоны public:

storable *find ( const storable &match_of_this ) const;

storable *successor ( void ) const;

virtual int operator== ( const storable &r ) const;

};

storable *storable::find( const storable &match_of_this ) const { // Возвращает указатель на первый элемент в списке (начиная с // себя), имеющий тот же ключ, что и match_of_this. Обычно, // объект-коллекция должен послать это сообщение объекту начала // списка, указатель на который хранится в классе коллекции.

storable *current = this;

for( ;

current;

current = current->next ) if( *current == match_of_this ) // найдено совпадение return current;

} storable *storable::successor( void ) const { // Возвращает следующее значение в последовательности.

return next;

} Функция operator==() должна быть чисто виртуальной, потому что отсутствует возможность ее реализации на уровне класса storable.

Реализация должна быть выполнена в производном классе13 :

class storable_string : public storable { string s;

public:

virtual int operator==( const storable &r ) const;

//...

};

virtual int operator==( const storable &r ) const { storable_string *right = dynamic_cast( &r );

return right ? (s == r.s) : NULL;

} Я здесь использовал предложенный в ISO/ANSI Cи++ безопасный механизм нисходящего приведения типов. right инициализируется значением NULL, если передаваемый объект (r) не относится к типу storable_string. Например, он может принадлежать к некоторому В действительности я бы использовал множественное наследование с участием класса string. Использованный здесь код имеет цель немного упростить пример.

226 Правила программирования на Си++ другому классу, также являющемуся наследником storable.

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

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

template class storable { storable *next, *prev;

t_key key;

public:

//...

storable *find ( const storable &match_me ) const;

storable *successor ( void ) const;

int operator==( const storable &r ) const;

};

template int storable::operator==( const storable &r ) const { return key == r.key ;

} template storable *storable::successor( void ) const { return next;

} template storable *storable::find( const storable &match_me ) const { storable *current = this;

for( ;

current;

current = current->next ) if( *current == match_me ) // найдено совпадение return current;

} Проблема здесь в непроизводительных затратах. Функции-члены шаблона класса сами являются шаблонами функций. Когда компилятор расширяет шаблон storable, он также расширяет варианты всех функций-членов этого шаблона. Хотя я их не показал, вероятно, в классе storable определено множество функций. Многие из этих функций будут похожи в том, что они не используют информацию о типе, передаваемую в шаблон.

См. предыдущее примечание к правилу 156. — Ред.

Шаблоны Это означает, что каждое расширение такой функции будет идентично по содержанию любому другому ее расширению. Из функций, которые не похожи на функцию successor(), большинство будут подобны find(), использующей информацию о типе, но которую легко изменить так, чтобы ее не использовать.

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

template class storable_tem : public storable { t_key key;

public:

// Замещение базового класса virtual int operator==( const storable &r ) const;

//...

};

template /* виртуальный */ int storable_tem::operator==( const storable &r ) const { t_key *right = dynamic_cast( &r );

return right ? (s == r.s) : NULL;

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

Полезным результатом является существенное сокращение размера кода. Механизм шаблонов может рассматриваться как средство автоматизации производства шаблонных производных классов.

228 Правила программирования на Си++ Часть 8и. Исключения 159. Назначение исключений — не быть пойманными Как правило, исключение должно быть возбуждено, если:

• Нет другого способа сообщить об ошибке (например, конструкторов, перегруженных операций и т.д.).

• Ошибка неисправимая (например, нехватка памяти).

• Ошибка настолько непонятная или неожиданная, что никому не придет в голову ее протестировать (например, printf).

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

some_obj x;

if( x.is_invalid() ) // конструктор не выполнился.

что, по меньшей мере, неаккуратно. Перегруженные операции являют собой ту же проблему. Единственным способом, которым использованная в x = a + b;

функция operator+() может сообщить об ошибке, является возврат неверного значения, которое будет скопировано в x. Вы могли бы затем написать:

if( x == INVALID ) //...

или нечто подобное. Снова весьма неаккуратно. Исключения также полезны для обработки ошибок, которые обычно являются фатальными.

Например, большинство программ просто вызовут exit(), если функция malloc() не выполнится. Все проверки типа:

if( !(p = malloc(size)) ) fatal_error( E_NO_MEMORY );

бесполезны, если оператор new просто не возвратит значения, когда ему не хватит памяти. Так как new на самом деле возбуждает исключение (по Исключения сравнению с вызовом exit()), то вы можете перехватить это исключение в тех редких случаях, когда вы можете что-то сделать в такой ситуации.

Также имеется и другая проблема. Одной из причин того, что комитет ISO/ANSI по Си++ требует, чтобы оператор new возбуждал исключение, если он не может выделить память, заключается в том, что кто-то провел исследование и обнаружил, что какая-то смехотворная доля ошибок времени выполнения в реальных программах вызвана людьми, не побеспокоившимися проверить, не вернула ли функция malloc() значение NULL. По причинам, обсуждаемым позже, я не думаю, что исключение должно быть использовано вместо возврата ошибки просто для защиты программистов от себя самих, но оно срабатывает с new, потому что эта ошибка обычно в любом случае неисправима. Лучшим примером может быть функция printf(). Большинство программистов на Си даже не знают, что printf() возвращает код ошибки. (Она возвращает количество выведенных символов, которое может быть равно 0, если на диске нет места). Программисты, которые не знают о возврате ошибки, склонны ее игнорировать. А это не очень хорошо для программы, которая осуществляет запись в перенаправленный стандартный вывод, продолжать, как будто все в порядке, поэтому можно считать хорошей идеей возбудить здесь исключение.

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

some_class obj;

try { obj.f();

} catch( some_class::error &r ) { // выполнить действие в случае ошибки } лучше читается, чем:

if( obj.f() == ERROR ) // выполнить действие в случае ошибки В любом случае, если try-блок содержит более одного вызова функций, вы не сможете просто исправить ошибку, потому что вы не сможете узнать, где возникла ошибка.

Следующий пример демонстрирует вторую проблему. Класс CFile, реализующий основной ввод/вывод двоичных файлов, возбуждает 230 Правила программирования на Си++ исключение в случае переполнения диска при записи, чего легко добиться на дискете. Более того, функция write() не возвращает никакого кода ошибки. Перехват исключения является единственным способом обнаружения ошибки. Вот пример того, как вы должны обнаруживать ошибку чтения:

char data[128];

Cfile f( "some_file", CFile::modeWrite );

try { f.Write( data, sizeof(data) );

} catch( CFileException &r ) { if( r.m_cause == CfileException::diskFull ) // что-то сделать } Имеется две проблемы. Первая явно связана с уродливостью этого кода. Я бы гораздо охотнее написал:

bytes_written = f.Write( data, sizeof(data));

if( bytes_written != sizeof(data) ) // разобраться с этим Вторая проблема одновременно более тонкая и более серьезная. Вы не сможете исправить эту ошибку. Во-первых, вы не знаете, сколько байтов было записано перед тем, как диск переполнился. Если Write() возвратила это число, то вы можете предложить пользователю сменить диск, удалить несколько ненужных файлов или сделать еще что-нибудь для освобождения места на диске. Вы не можете тут сделать это, потому что не знаете, какая часть буфера уже записана, поэтому вы не знаете, откуда начинать запись на новый диск.

Даже когда Write() возвратила количество записанных байтов, то вы все еще не можете исправить ошибку. Например, даже если функцию CFile переписать, как показано ниже, то она все равно не будет работать:

char data[128];

CFile f( "some_file", CFile::modeWrite );

int bytes_written;

try { bytes_written = f.Write( data, sizeof(data) );

} catch( CFileException &r ) { Исключения if( r.m_cause == CFileException::diskFull ) // что-то выполнить.

// при этом переменная bytes_written содержит мусор.

} Управление передается прямо откуда-то изнутри Write() в обработчик catch при возбуждении исключения, перескакивая через все операторы return внутри Write(), а также через оператор присваивания в вызывающейся функции;

переменная bytes_written остается неинициализированной. Я думаю, что вы могли бы передать Write() указатель на переменную, которую она могла использовать для хранения числа записанных байтов перед тем, как выбросить исключение, но это не будет значительным улучшением. Лучшим решением будет отказ от возбуждения исключения и возврат или числа записанных байтов, или какого-то эквивалента индикатора ошибки.

Последней проблемой являются непроизводительные затраты.

Обработка исключения вызывает очень большие непроизводительные затраты, выражающиеся в возрастании в несколько раз размера кода и времени выполнения. Это происходит даже в операционных системах типа Microsoft Windows NT, которые поддерживают обработку исключений на уровне операционной системы. Вы можете рассчитывать на 10-20% увеличение размера кода и падение скорости выполнения на несколько процентов при интенсивном использовании исключений. Следовательно, исключения должны использоваться лишь тогда, когда непроизводительные затраты не берутся в расчет;

обычно, при наличии возможности, предпочесть возврат ошибки.

160. По возможности возбуждайте объекты типа error Листинг 15 показывает простую систему определений класса для возбуждения исключений. Я могу перехватить ошибки чтения или записи подобным образом:

try { file f("name", "rw");

buffer b;

b = f.read();

f.write( b );

} catch( file::open_error &r ) { Я определил это для 32-разрядного компилятора Visual C++ Microsoft;

другие компиляторы показывают или сравнимые результаты, или худшие.

232 Правила программирования на Си++ // Файл не существует или не может быть открыт.

} catch( file::io_error &r ) { // Какая-то из неисправимых ошибок ввода/вывода.

} Если меня волнует лишь то, что произошла ошибка определенного вида, и не волнует, какого конкретно, то я могу сделать так:

file f;

try { buffer b;

b = f.read() f.write( b );

} catch( file::error &r ) { //...

} Листинг 15. Классы исключений 1 class file 2 { 3 public:

4 class error {};

5 class open_error : public error {};

6 class io_error : public error {};

8 //...

9 } Этот код работает, потому что объект file::read_error является объектом типа file::error (так как относится к производному классу).

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

Я мог бы также предложить другой класс, использующий тот же самый механизм:

class long_double { public:

class error {};

class didvide_by_zero : public error {};

//...

};

Так как классы error являются вложенными определениями, то именами на самом деле являются file::error и long_double::error, Исключения поэтому здесь нет конфликта имен.

Для упрощения сопровождения я всегда использую error в качестве своего базового класса для исключений. (Я не мог использовать производный класс, даже если здесь был бы возможен всего один вид ошибки). Таким образом, я знаю, что, имея возбуждающий исключение класс some_class, можно перехватить это исключение при помощи:

catch(some_class::error &r) Эту ошибку искать не придется. Если применяется наследование, то я использую базовый класс error таким образом:

class employee { public:

class error {};

class database_access_error : public error {};

};

class peon : public employee { class error : public employee::error {};

class aagh : public error {};

};

Этим способом исключение aagh может быть перехвачено как peon::aagh, peon::error или employee::error.

Нет смысла создавать класс глобального уровня error, от которого наследуются все локальные классы error, потому что для обработки этой ситуации вы можете использовать обработчик catch(…).

161. Возбуждение исключений из конструктора ненадежно Я начну этот раздел с замечания о том, что компиляторы, которые соответствуют рабочим документам комитета ISO/ANSI по Си++, не имеют большей части из рассматриваемых здесь проблем. Тем не менее, многие компиляторы (один из которых компилятор Microsoft) им не соответствуют.

Ошибки в конструкторах являются действительной проблемой Си++.

Так как они не вызываются явно, то и не могут возвратить коды ошибок обычным путем. Задание для конструируемого объекта "неверного" значения в лучшем случае громоздко и иногда невозможно. Возбуждение исключения может быть здесь решением, но при этом нужно учесть множество вопросов. Рассмотрим следующий код:

class c 234 Правила программирования на Си++ { class error {};

int *pi;

public:

c() { throw error();

} //...

};

void f( void ) { try { c *cp = new c;

// cp не инициализируется, если не // выполняется конструктор //...

delete cp;

// эта строка в любом случае не выполнится.

} catch( c::error &err ) { printf ("Сбой конструктора\n");

delete cp;

// Дефект: cp теперь содержит мусор } } Проблема состоит в том, что память, выделенная оператором new, никогда не освобождается. То есть, компилятор сначала выделяет память, затем вызывает конструктор, который возбуждает объект error. Затем управление передается прямо из конструктора в catch-блок. Код, которым возвращаемое значение оператора new присваивается cp, никогда не выполняется — управление просто перескакивает через него.

Следовательно, отсутствует возможность освобождения памяти, потому что у вас нет соответствующего указателя. Чтение мной рабочих документов комитета ISO/ANSI по Си++ показало, что такое поведение некорректно — память должна освобождаться неявно. Тем не менее, многие компиляторы делают это неправильно.

Вот простой способ исправить эту сложную ситуацию (я поместил тело функции в определение класса лишь для того, чтобы сделать пример покороче):

class с { int *pi;

public:

c() { /*...*/ throw this;

} };

void f( void ) Исключения { try { c *cp = NULL;

cp = new c;

c a_c_object();

} catch( c *points_at_unconstructed_object ) { if( !cp ) // если конструктор, вызванный посредством // new, не выполняется delete points_at_unconstructed_object;

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

void f( void ) { c *cp = NULL;

// cp должен быть объявлен снаружи try-блока, // потому что try-блок образует область // действия, поэтому cp не может быть // доступным в catch-блоке будучи объявлен в // try-блоке.

try { c a_c_object;

cp = new c;

} catch( c *points_at_unconstructed_object ) { if( !cp ) // если конструктор, вызванный посредством // new, не выполняется delete points_at_unconstructed_object;

} } Вы не можете решить эту проблему внутри конструктора, потому что для конструктора нет возможности узнать, получена ли инициализируемая им память от new, или из стека.

Во всех предыдущих примерах деструктор для сбойных объектов вызывается, даже если конструктор не выполнился и возбудил исключение. (Он вызывается или косвенно посредством оператора delete, или неявно при выходе объекта из области действия, даже если он покидает ее из-за возбуждения исключения).

Аналогично, вызов delete косвенно вызывает деструктор для этого 236 Правила программирования на Си++ объекта. Я сейчас вернусь к этой ситуации. Перед выходом из этого деструктора незавершенный конструктор должен привести объект в исходное состояние перед тем, как сможет возбудить ошибку. С учетом предшествующего определения класса c следующий код будет работать при условии, что отсутствует ошибка до оператора new int[128] и new выполнен успешно:

c::c( ) { if( some_error() ) throw error(this);

// ДЕФЕКТ: pi не инициализирован.

//...

pi = new int[128];

// ДЕФЕКТ: pi не инициализирован, // если оператор new возбуждает // исключение.

//...

if( some_other_error() ) { delete [] pi;

// Не забудьте сделать это.

throw error(this);

// Это возбуждение безопасно } } c::~c( ) { delete pi;

} Запомните, что pi содержит мусор до своей инициализации оператором new. Если возбуждается исключение до вызова new или сам оператор new возбудит исключение, то тогда pi никогда не инициализируется.

(Вероятно, оно не будет содержать NULL, а будет просто не инициализированно). Когда вызывается деструктор, то оператору delete передается это неопределенное значение. Решим проблему, инициализировав этот указатель безопасным значением до того, как что либо испортится:

c::c( ) : pi(NULL) // инициализируется на случай, если оператор // new даст сбой { if( some_error() ) throw error(this);

// Это возбуждение теперь безопасно.

//...

pi = new int[128];

// Сбой оператора new теперь безопасен.

//...

if( some_other_error() ) { delete [] pi;

// Не забудьте высвободить динамическую // память.

Исключения throw error(this);

// Это возбуждение безопасно.

} } c::~c( ) { if( pi ) delete pi;

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

У вас есть возможность почистить предложенный выше код при его использовании с учетом моего совета из предыдущего правила о возбуждении исключения объекта error и скрытия всех сложностей в этом объекте. Однако определение этого класса получается значительно более сложным. Реализация в листинге 16 опирается на тот факт, что деструктор явно объявленного объекта должен вызываться при выходе из try-блока, перед выполнением catch-блока. Деструктор для объекта, полученного при помощи new, не будет вызван до тех пор, пока память не будет передана оператору delete, что происходит в сообщении destroy(), посланном из оператора catch. Следовательно, переменная has_been_destroyed будет содержать истину, если объект получен не при помощи new, и исключение возбуждено из конструктора, и ложь — если объект получен посредством new, потому что деструктор еще не вызван.

Конечно, вы можете вполне резонно заметить, что у меня нет причин проверять содержимое объекта, который по теории должен быть уничтожен. Здесь уже другая проблема. Некоторые компиляторы (в том числе компилятор Microsoft Visual C++ 2.2) вызывают деструктор после выполнения оператора catch, даже если объекты, определенные в try блоке, недоступны из catch-блока. Следовательно, код из листинга 16 не будет работать после этих компиляторов. Вероятно, лучшие решение состояло бы в написании варианта operator new(), который мог бы надежно указывать, получена память из кучи или из стека.

238 Правила программирования на Си++ Листинг 16. except.cpp — возбуждение исключения из конструктора 1 class с 2 { 3 public:

4 class error 5 { 6 c *p;

// NULL при успешном выполнении конструктора 7 public:

8 error( c *p_this );

9 void destroy( void );

10 };

12 private:

14 unsigned has_been_destroyed : 1;

15 int *pi;

17 private: friend class error;

18 int been_destroyed( void );

20 public:

21 c() ;

22 ~c();

24 };

25 //======================================================== 26 c::error::error( c *p_this ) : p( p_this ) {} 27 //------------------------------------------------------- 28 void c::error::destroy( void ) 29 { 30 if( p && !p->been_destroyed() ) 31 delete p;

32 } 33 //======================================================== 34 c::c() : has_been_destroyed( 0 ) 35 { 36 //...

37 throw error(this);

38 //...

39 } 40 //------------------------------------------------------- 41 c::~c() 42 { 43 //...

44 has_beeb_destroyed = 1;

45 } 46 //------------------------------------------------------- 47 int c::been_destroyed( void ) 48 { 49 return has_been_destroyed;

50 } Исключения 51 //======================================================== 52 void main( void ) 53 { 54 try 55 { 56 c *cp = new c;

57 c a_c_object;

59 delete cp;

60 } 61 catch( c::error &err ) 62 { 63 err.destroy();

// деструктор вызывается, только если 64 } // объект создан оператором new 65 } 240 Заключение Заключение Вот так-то. Множество правил, которые я считаю полезными и которые, надеюсь, будут полезны и для вас. Конечно, многие из представленных здесь правил дискуссионны. Пожалуйста, я готов с вами о них поспорить.

Несомненно, я не считаю себя каким-то законодателем в стиле Си++ и сам нарушаю многие из этих правил при случае;

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

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

Об авторе Об авторе Ален Голуб — программист, консультант и преподаватель, специализирующийся на Си++, объектно-ориентированном проектировании и операционных системах Microsoft. Он проводит семинары по приглашению частных фирм повсюду на территории США и преподает в филиалах Калифорнийского университета, расположенных в Беркли и Санта-Круз. Он также работает программистом и консультантом по объектно-ориентированному проектированию, используя Си и Си++ в операционных средах Microsoft Windows, Windows-95, Windows NT и UNIX.

М-р Голуб регулярно пишет для различных компьютерных журналов, включая "Microsoft Systems Journal", "Windows Tech Journal" и изредка "BYTE". Его популярная колонка "Сундучок с Си", публиковавшаяся в "Dr.Dobb's Journal" с 1983 по 1987 годы, стала для многих людей первым введением в Си. В число его книг входят "Compiler Design in C", "C+C++" и "The C Companion". М-р Голуб сочиняет музыку и имеет лицензию частного пилота.

Вы можете связаться с ним через Интернет по адресу allen@holub.com или через его фирму Software Engineering Consultants, P.O.Box 5679, Berkeley, CA 94705 (телефон и факс: (510) 540-7954).

Pages:     | 1 |   ...   | 2 | 3 ||



© 2011 www.dissers.ru - «Бесплатная электронная библиотека»

Материалы этого сайта размещены для ознакомления, все права принадлежат их авторам.
Если Вы не согласны с тем, что Ваш материал размещён на этом сайте, пожалуйста, напишите нам, мы в течении 1-2 рабочих дней удалим его.