Явная специализация шаблона А

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

// обобщенное определение шаблона

template <class T>

T max( T t1, T t2 ) {

return ( t1 > t2 ? t1 : t2 );

}

Когда этот шаблон конкретизируется с аргументом типа const char*, то обобщенное определение оказывается семантически некорректным, если мы интерпретируем каждый аргумент как строку символов в смысле языка C, а не как указатель на символ. В этом случае необходимо предоставить специализированное определение для конкретизации шаблона.

Явное определение специализации – это такое определение, в котором за ключевым словом template следует пара угловых скобок <>, а за ними – определение специализированного шаблона. Здесь указывается имя шаблона, аргументы, для которых он специализируется, список параметров функции и ее тело. В следующем примере для max(const char*, const char*) определена явная специализация:

#include <cstring>

// явная специализация для const char*:

// имеет приоритет над конкретизацией шаблона

// по обобщенному определению

typedef const char *PCC;

template<> PCC max< PCC >( PCC s1, PCC s2 ) {

return ( strcmp( s1, s2 ) > 0 ? s1 : s2 );

Поскольку имеется явная специализация, шаблон не будет конкретизирован с типом const char* при вызове в программе функции max(const char*, const char*). При любом обращении к max() с двумя аргументами типа const char*

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

#include <iostream>

// здесь должно быть определение шаблона функции max()

// и его специализации для аргументов const char*

int main() {

   // вызов конкретизированной функции: int max< int >( int, int );

   int i = max( 10, 5 );

   // вызов явной специализации:

   // const char* max< const char* >( const char*, const char* );

   const char *p = max( "hello", "world" );

   cout << "i: " << i << " p: " << p << endl;

   return 0;

}

Можно объявлять явную специализацию шаблона функции, не определяя ее. Например, для функции max(const char*, const char*) она объявляется так:

// объявление явной специализации шаблона функции

template< > PCC max< PCC >( PCC, PCC );

При объявлении или определении явной специализации шаблона функции нельзя опускать слово template и следующую за ним пару скобок <>. Кроме того, в объявлении специализации обязательно должен быть список параметров функции:

// ошибка: неправильные объявления специализации

// отсутствует template<>

PCC max< PCC >( PCC, PCC );

// отсутствует список параметров

template<> PCC max< PCC >;

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

// правильно: аргумент шаблона const char* выводится из типов параметров

template<> PCC max( PCC, PCC );

В следующем примере шаблон функции sum()

явно специализирован:

template <class T1, class T2, class T3>

T1 sum( T2 op1, T3 op2 );

// объявления явных специализаций

// ошибка: аргумент шаблона для T1 не может быть выведен;

// он должен быть задан явно

template<> double sum( float, float );

// правильно: аргумент для T1 задан явно,

// T2 и T3 выводятся и оказываются равными float

template<> double sum<double>( float, float );

// правильно: все аргументы заданы явно

<

template<> int sum<int,char>( char, char );

Пропуск части template<> в объявлении явной специализации не всегда является ошибкой. Например:

// обобщенное определение шаблона

template <class T>

T max( T t1, T t2 ) { /* ... */ }

// правильно: обычное объявление функции

const char* max( const char*, const char*);

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

Так почему бы просто не объявить обычную функцию? Как было показано в разделе 10.3, для преобразования фактического аргумента функции, конкретизированной по шаблону, в соответствующий формальный параметр в случае, когда этот аргумент принимает участие в выводе аргумента шаблона, может быть применено лишь ограниченное множество преобразований типов. Точно так же обстоит дело и в ситуации, когда шаблон функции специализируется явно: к фактическим аргументам функции при этом тоже применимо лишь ограниченное множество преобразований. Явные специализации не помогают обойти соответствующие ограничения. Если мы хотим выйти за их пределы, то должны определить обычную функцию вместо специализации шаблона. (В разделе 10.8 этот вопрос рассматривается более подробно; там же показано, как работает разрешение перегруженной функции для вызова, который соответствует как обычной функции, так и экземпляру, конкретизированному из шаблона.)

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

лишь объявлен к моменту специализации. Хотя определение шаблона не обязательно, объявление все же требуется. То, что sum() – шаблон, должно быть известно до того, как это имя может быть специализировано.

Такое объявление должно быть видимо до его использования в исходном файле. Например:

#include <iostream>

#include <cstring>

// обобщенное определение шаблона

template <class T>

   T max( T t1, T t2 ) { /* ... */ }

int main() {

   // конкретизация функции

   // const char* max< const char* >( const char*, const char* );

   const char *p = max( "hello", "world" );

   cout << "p: " << p << endl;

   return 0;

}

// некорректная программа: явная специализация const char *:

// имеет приоритет над обобщенным определением шаблона

typedef const char *PCC;

template<> PCC max< PCC >(PCC s1, PCC s2 ) { /* ... */ }

В предыдущем примере конкретизация max(const char*, const char*) предшествует объявлению явной специализации. Поэтому компилятор имеет право предположить, что функция должна быть конкретизирована по обобщенному определению шаблона. Однако в программе не может одновременно существовать явная специализация и экземпляр, конкретизированный по тому же шаблону с тем же множеством аргументов. Когда в исходном файле после конкретизации встречается явная специализация

max(const char*, const char*), компилятор выдает сообщение об ошибке.

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

// --------- max.h -------

// обобщенное определение шаблона

template <class Type>

   Type max( Type t1, Type t2 ) { /* ... */ }

// --------- File1.C -------

#include <iostream>

#include "max.h"

void another();

int main() {

   // конкретизация функции

   // const char* max< const char* >( const char*, const char* );

   const char *p = max( "hello", "world" );

   cout << "p: " << p << endl;

   another();

   return 0;

}

// --------- File2.C -------

#include <iostream>

#include <cstring>

#include "max.h"

// явная специализация шаблона для const char*

typedef const char *PCC;

template<> PCC max< PCC >( PCC s1, PCC s2 ) { /* ... */ }

void another() {

   // явная специализация

   // const char* max< const char* >( const char*, const char* );

   const char *p = max( "hi", "again" );

   cout << " p: " << p << endl;

   return 0;

<

}

Эта программа состоит из двух файлов. В файле File1.C нет объявления явной специализации max(const char*, const char*). Вместо этого шаблон функции конкретизируется из обобщенного определения. В файле File2.C

объявлена явная специализация, и при обращении к max("hi", "again")

именно она и вызывается. Поскольку в одной и той же программе функция max(const char*, const char*) то конкретизируется по шаблону, то специализируется явно, компилятор считает программу некорректной. Для исправления этого объявление явной специализации шаблона должно предшествовать вызову функции max(const char*, const char*) в файле File1.C.

Чтобы избежать таких ошибок и гарантировать, что объявление явной специализации шаблона max(const char*, const char*) внесено в каждый файл, где используется шаблон функции max() с аргументами типа const char*, это объявление следует поместить в заголовочный файл "max.h" и включать его во все исходные файлы, в которых используется шаблон max():

// --------- max.h -------

// обобщенное определение шаблона

template <class Type>

   Type max( Type t1, Type t2 ) { /* ... */ }

// объявление явной специализации шаблона для const char*

typedef const char *PCC;

template<> PCC max< PCC >( PCC s1, PCC s2 );

// --------- File1.C -------

#include <iostream>

#include "max.h"

void another();

int main() {

   // специализация

   // const char* max< const char* >( const char*, const char* );

   const char *p = max( "hello", "world" );

   // ....

}

Упражнение 10.10

Определите шаблон функции count() для подсчета числа появлений некоторого значения в массиве. Напишите вызывающую программу. Последовательно передайте в ней массив значений типа double, int и сhar. Напишите специализированный экземпляр шаблона count() для обработки строк.

Явное преобразование типов

Явное преобразование типов производится при помощи следующих операторов: static_cast, dynamic_cast, const_cast и reinterpret_cast. Заметим, что, хотя иногда явное преобразование необходимо, оно служит потенциальным источником ошибок, поскольку подавляет проверку типов, выполняемую компилятором. Давайте сначала посмотрим, зачем нужно такое преобразование.

Указатель на объект любого неконстантного типа может быть присвоен указателю типа

void*, который используется в тех случаях, когда действительный тип объекта либо неизвестен, либо может меняться в ходе выполнения программы. Поэтому указатель void*

иногда называют универсальным

указателем. Например:

int iva1;

int *pi = 0;

char *pc = 0;

void *pv;

pv = pi; // правильно: неявное преобразование

pv = pc; // правильно: неявное преобразование

const int *pci = &iva1;

pv = pci; // ошибка: pv имеет тип, отличный от const void*;

const void *pcv = pci; // правильно

Однако указатель void* не может быть разыменован непосредственно. Компилятор не знает типа объекта, адресуемого этим указателем. Но это известно программисту, который хочет преобразовать указатель void* в указатель определенного типа. С++ не обеспечивает подобного автоматического преобразования:

#inc1ude <cstring>

int ival = 1024;

void *pv;

int *pi = &iva1;

const char *pc = "a casting call";

void mumble() {

pv = pi; // правильно: pv получает адрес ival

pc = pv; // ошибка: нет стандартного преобразования

char *pstr = new char[ str1en( pc )+1 ];

strcpy( pstr, pc );

}

Компилятор выдает сообщение об ошибке, так как в данном случае указатель pv

содержит адрес целого числа ival, и именно этот адрес пытаются присвоить указателю на строку. Если бы такая программа была допущена до выполнения, то вызов функции strcpy(), которая ожидает на входе строку символов с нулем в конце, скорее всего привел бы к краху, потому что вместо этого strcpy() получает указатель на целое число. Подобные ошибки довольно просто не заметить, именно поэтому С++ запрещает неявное преобразование указателя на void в указатель на другой тип. Однако такой тип можно изменить явно:

void mumble 0 {

    // правильно: программа по-прежнему содержит ошибку,

    // но теперь она компилируется!

    // Прежде всего нужно проверить

    // явные преобразования типов...

    pc = static_cast< char* >( pv );

    char *pstr = new char[ str1en( pc )+1 ];

    // скорее всего приведет к краху

    strcpy( pstr, pc );

}

Другой причиной использования явного преобразования типов может служить необходимость избежать стандартного преобразования или выполнить вместо него собственное. Например, в следующем выражении ival

сначала преобразуется в double, потом к нему прибавляется dval, и затем результат снова трансформируется в int.

double dval;

int iva1;

ival += dval;

Можно уйти от ненужного преобразования, явно заменив dval на int:

ival += static_cast< int >( dval );

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

Синтаксис операции явного преобразования типов таков:

cast-name< type >( expression );

Здесь cast-name – одно из ключевых слов static_cast, const_cast, dynamic_cast или reinterpret_cast, а type – тип, к которому приводится выражение expression.

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

служит для трансформации константного типа в неконстантный и подвижного (volatile) – в неподвижный. Например:

extern char *string_copy( char* );

const char *pc_str;

char *pc = string_copy( const_cast< char* >( pc_str ));

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

С применением static_cast

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

double d = 97.0;

<

char ch = static_cast< char >( d );

Зачем использовать static_cast? Дело в том, что без него компилятор выдаст предупреждение о возможной потере точности. Применение оператора static_cast

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

Кроме того, с помощью static_cast

указатель void*

можно преобразовать в указатель определенного типа, арифметическое значение – в значение перечисления (enum), а базовый класс – в производный. (О преобразованиях типов базовых и производных классов говорится в главе 19.)

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

enum mumble { first = 1, second, third };

extern int ival;

mumble mums_the_word = static_cast< mumble >( ival );

Трансформация ival в mumble

будет правильной только в том случае, если ival равен 1, 2 или 3.

reinterpret_cast

работает с внутренними представлениями объектов (re-interpret – другая интерпретация того же внутреннего представления), причем правильность этой операции целиком зависит от программиста. Например:

complex<double> *pcom;

char *pc = reinterpret_cast< char* >( pcom );

Программист не должен забыть или упустить из виду, какой объект реально адресуется указателем char* pc. Формально это указатель на строку встроенного типа, и компилятор не будет препятствовать использованию pc для инициализации строки:

string str( pc );

хотя скорее всего такая команда вызовет крах программы.

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

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

В некотором смысле это отражает фундаментальный парадокс языка С++: строгая проверка типов призвана не допустить подобных ошибок, в то же время наличие операторов явного преобразования позволяет “обмануть” компилятор и использовать объекты разных типов на свой страх и риск. В нашем примере мы “отключили” проверку типов при инициализации указателя pc и присвоили ему адрес комплексного числа. При инициализации строки str такая проверка производится снова, но компилятор считает, что pc указывает на строку, хотя, на самом-то деле, это не так!

Четыре оператора явного преобразования типов были введены в стандарт С++ как наименьшее зло при невозможности полностью запретить такое приведение. Устаревшая, но до сих пор поддерживаемая стандартом С++ форма явного преобразования выглядит так:

char *pc = (char*) pcom;

Эта запись эквивалентна применению оператора reinterpret_cast, однако выглядит не так заметно. Использование операторов xxx_cast

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

Если поведение программы становится ошибочным и непонятным, возможно, в этом виноваты явные видоизменения типов указателей. Использование операторов явного преобразования помогает легко обнаружить места в программе, где такие операции выполняются. (Другой причиной непредсказуемого поведения программы может стать нечаянное уничтожение объекта (delete), в то время как он еще должен использоваться в работе. Мы поговорим об этом в разделе 8.4, когда будем обсуждать динамическое выделение памяти.)

Оператор dynamic_cast

применяется при идентификации типа во время выполнения (run-time type identification). Мы вернемся к этой проблеме лишь в разделе 19.1.

Явное задание аргументов шаблона A

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

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

// конкретизируется min5( unsigned int, unsigned int )

min5< unsigned int >( ui, 1024 );

В этом случае список аргументов шаблона <unsigned int> явно задает их типы. Поскольку аргумент шаблона теперь известен, вызов функции больше не приводит к ошибке.

Обратите внимание, что при вызове функции min5() второй аргумент равен 1024, т.е. имеет тип int. Так как тип второго формального параметра функции при явном задании аргумента шаблона установлен в unsigned int, то второй фактический параметр функции приводится к типу unsigned int с помощью стандартного преобразования целых типов.

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

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

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

// каким должен быть тип возвращаемого значения: T или U

template <class T, class U>

??? sum( T, U );

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

char ch; unsigned int ui;

// ни T, ни U нельзя использовать в качестве типа возвращаемого значения

sum( ch, ui ); // правильно: U sum( T, U );

sum( ui, ch ); // правильно: T sum( T, U );

Решение заключается в том, чтобы ввести в шаблон третий параметр для обозначения типа возвращаемого значения:

// T1 не появляется в списке параметров шаблона функции

template <class T1, class T2, class T3>

T1 sum( T2, T3 );

Поскольку тип возвращаемого значения может отличаться от типов аргументов функции, T1 не упоминается в списке формальных параметров. Это потенциальная проблема, так как тип T1 не может быть выведен из фактических аргументов функции. Однако, если при конкретизации sum() мы зададим аргументы шаблона явно, то избегнем сообщения компилятора о невозможности вывести T1.

Например:

typedef unsigned int ui_type;

ui_type calc( char ch, ui_type ui ) {

   // ...

   // ошибка: невозможно вывести T1

   ui_type loc1 = sum( ch, ui );

   // правильно: аргументы шаблона заданы явно

   // T1 и T3 - это unsigned int, T2 - это char

   ui_type loc2 = sum< ui_type, ui_type >( ch, ui );

}

Не хватает возможности явно задать T1, но не T2 и T3, поскольку их можно вывести из аргументов функции при вызове.

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

// правильно: T3 - это unsigned int

// T3 выведен из типа ui

ui_type loc3 = sum< ui_type, char >( ch, ui );

// правильно: T2 - это char, T3 - unsigned int

// T2 и T3 выведены из типа pf

ui_type (*pf)( char, ui_type ) = &sum< ui_type >;

// ошибка: опускать можно только “хвостовые” аргументы

<

ui_type loc4 = sum< ui_type, , ui_type >( ch, ui );

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

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

template <class T1, class T2, class T3>

   T1 sum( T2 op1, T3 op2 ) { /* ... */ }

void manipulate( int (*pf)( int,char ) );

void manipulate( double (*pf)( float,float ) );

int main()

{

   // ошибка: какой из возможных экземпляров sum:

   // int sum( int,char ) или double sum( float, float )?

   manipulate( &sum );

   // берется адрес конкретизированного экземпляра

   // double sum( float, float )

   // вызывается: void manipulate( double (*pf)( float, float ) );

   manipulate( &sum< double, float, float > );

}

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

Упражнение 10.6

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

Упражнение 10.7

Пусть дано следующее определение шаблона функции sum():

template <class T1, class T2, class T3>

T1 sum( T2, T3 );

Какие из приведенных ниже вызовов ошибочны? Почему?

double dobj1, dobj2;

float fobj1, fobj2;

char cobj1, cobj2;

(a) sum( dobj1, dobj2 );

(b) sum<double,double,double>( fobj1, fobj2 );

(c) sum<int>( cobj1, cobj2 );

(d) sum<double, ,double>( fobj2, dobj2 );

Явные объявления конкретизации

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

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

Подобные проблемы, характерные для старых компиляторов, затрудняли использование шаблонов. Поэтому в стандарте C++ введено понятие явного объявления конкретизации, помогающее программисту управлять моментом, когда конкретизация происходит.

В явном объявлении конкретизации за ключевым словом template идет объявление шаблона функции, в котором его аргументы указаны явно. Рассмотрим шаблон sum(int*, int):

template <typename Type>

Type sum( Type op1, Type op2 ) { /* ... */ }

// явное объявление конкретизации

template int* sum< int* >( int*, int );

Здесь в качестве аргумента явно задается int*. Явное объявление конкретизации с одним и тем же множеством аргументов шаблона может встречаться в программе не более одного раза.

Определение шаблона функции должно находиться в том же файле, где и явное объявление конкретизации. Если же его не видно, то явное объявление приводит к ошибке:

#include <vector>

template <typename Type>

Type sum( Type op1, int op2 ); // только объявление

// определяем typedef для vector< int >

typedef vector< int > VI;

// ошибка: sum() не определен

Явный вызов деструктора

Иногда вызывать деструктор для некоторого объекта приходится явно. Особенно часто такая необходимость возникает в связи с оператором new (см. раздел 8.4). Рассмотрим пример. Когда мы пишем:

char *arena = new char[ sizeof Image ];

то из хипа выделяется память, размер которой равен размеру объекта типа Image, она не инициализирована и заполнена случайными битами. Если же написать:

Image *ptr = new (arena) Image( "Quasimodo" );

то никакой новой памяти не выделяется. Вместо этого переменной ptr

присваивается адрес, ассоциированный с переменной arena. Теперь память, на которую указывает ptr, интерпретируется как занимаемая объектом класса Image, и конструктор применяется к уже существующей области. Таким образом, оператор размещения new()

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

Закончив работать с изображением Quasimodo, мы можем произвести какие-то операции с изображением Esmerelda, размещенным по тому же адресу arena в памяти:

Image *ptr = new (arena) Image( "Esmerelda" );

Однако изображение Quasimodo при этом будет затерто, а мы его модифицировали и хотели бы записать на диск. Обычно сохранение выполняется в деструкторе класса Image, но если мы применим оператор delete:

// плохо: не только вызывает деструктор, но и освобождает память

delete ptr;

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

ptr->~Image();

сохранив отведенную под изображение память для последующего вызова оператора размещения new.

Отметим, что, хотя ptr и arena

адресуют одну и ту же область памяти в хипе, применение оператора delete к arena

// деструктор не вызывается

delete arena;

не приводит к вызову деструктора класса Image, так как arena

имеет тип char*, а компилятор вызывает деструктор только тогда, когда операндом в delete

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

Как определить последовательный контейнер?

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

#include <vector>

#inclnde <list>

#include <deque>

#include <map>

#include <set>

Определение контейнера начинается именем его типа, за которым в угловых скобках следует тип данных его элементов[12]. Например:

vector< string > svec;

list< int > ilist;

Переменная svec

определяется как вектор, способный содержать элементы типа string, а ilist – как список с элементами типа int. Оба контейнера при таком определении пусты. Чтобы убедиться в этом, можно вызвать функцию-член empty():

if ( svec.empty() != true )

; // что-то не так

Простейший метод вставки элементов – использование функции-члена push_back(), которая добавляет элементы в конец контейнера. Например:

string text_word;

while ( cin >> text_word )

svec.push_back( text_word );

Здесь строки из стандартного ввода считываются в переменную text_word, и затем копия каждой строки добавляется в контейнер svec с помощью push_back().

Список имеет функцию-член push_front(), которая добавляет элемент в его начало. Пусть есть следующий массив:

int ia[ 4 ] = { 0, 1, 2, 3 };

Использование push_back()

for ( int ix=0; ix<4; ++ix )

ilist.push_back( ia[ ix ] );

создаст последовательность 0, 1, 2, 3, а push_front()

for ( int ix=0; ix<4; ++ix )

ilist.push_front( ia[ ix ] );

создаст последовательность 3, 2, 1, 0. [13]

Мы можем при создании явно указать размер массива – как константным, так и неконстантным выражением:

#include <list>

#include <vector>

#include <string>

extern int get_word_count( string file_name );

const int list_size = 64;

list< int > ilist( list_size );

vector< string > svec(get_word_count(string("Chimera")));

Каждый элемент контейнера инициализируется значением по умолчанию, соответствующим типу данных. Для int это 0. Для строкового типа вызывается конструктор по умолчанию класса string.

Мы можем указать начальное значение всех элементов:

list< int > ilist( list_size, -1 );

vector< string > svec( 24, "pooh" );

Разрешается не только задавать начальный размер контейнера, но и впоследствии изменять его с помощью функции-члена resize(). Например:

svec.resize( 2 * svec.size() );

Размер svec в этом примере удваивается. Каждый новый элемент получает значение по умолчанию. Если мы хотим инициализировать его каким-то другим значением, то оно указывается вторым параметром функции-члена resize():

// каждый новый элемент получает значение "piglet"

svec.resize( 2 * svec.size(), "piglet" );

Кстати, какова наиболее вероятная емкость svec при определении, если его начальный размер равен 24? Правильно, 24! В общем случае минимальная емкость вектора равна его текущему размеру. При удвоении размера емкость, как правило, тоже удваивается

Мы можем инициализировать новый контейнер с помощью существующего. Например:

vector< string > svec2( svec );

list< int >      ilist2( ilist ) ;

Каждый контейнер поддерживает полный набор операций сравнения: равенство, неравенство, меньше, больше, меньше или равно, больше или равно. Сопоставляются попарно все элементы контейнера. Если они равны и размеры контейнеров одинаковы, то эти контейнеры равны; в противном случае – не равны. Результат операций “больше” или “меньше” определяется сравнением первых двух неравных элементов. Вот что печатает программа, сравнивающая пять векторов:

ivecl: 1 3 5 7 9 12

ivec2: 0 1 1 2 3 5 8 13

ivec3: 1 3 9

ivec4: 1 3 5 7

ivec5: 2 4

// первый неравный элемент: 1, О

// ivecl больше чем ivec2

ivecl < ivec2 //false

ivec2 < ivecl //true

// первый неравный элемент: 5, 9

ivecl < ivec3 //true

// все элементы равны, но ivec4 содержит меньше элементов

// следовательно, ivec4 меньше, чем ivecl

ivecl < ivec4 //false

// первый неравный элемент: 1, 2

ivecl < ivec5 //true

ivecl == ivecl //true

ivecl == ivec4 //false

ivecl != ivec4 //true

ivecl > ivec2 //true

ivec3 > ivecl //true

ivec5 > ivec2 //true

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

·                  операция “равно”;

·                  операция “меньше” (все операции сравнения контейнеров, о которых говорилось выше, используют только эти две операции сравнения);

·                  значение по умолчанию (для класса это означает наличие конструктора по умолчанию).

Все предопределенные типы данных, включая указатели и классы из стандартной библиотеки С++ удовлетворяют этим требованиям.

Упражнение 6.5

Объясните, что делает данная программа:

#include <string>

#include <vector>

#include <iostream>

#int main()

{

    vector<string> svec;

    svec.reserve( 1024 );

    string text_word;

    while ( cin >> text_word )

        svec.push_back( text_word );

    svec.resize( svec.size()+svec.size()/2 );

    // ...

}

Упражнение 6.6

Может ли емкость контейнера быть меньше его размера? Желательно ли, чтобы емкость была равна размеру: изначально или после вставки элемента? Почему?

Упражнение 6.7

Если программа из упражнения 6.5 прочитает 256 слов, то какова наиболее вероятная емкость контейнера после изменения размера? А если она считает 512 слов? 1000? 1048?

Упражнение 6.8

Какие из данных классов не могут храниться в векторе:

(a) class cl1 {

public:

    c11( int=0 );

    bool operator==();

    bool operator!=();

    bool operator<=();

    bool operator<();

// ...

};

(b) class c12 {

public:

    c12( int=0 );

    bool operator!=();

    bool operator<=();

    // ...

};

(с) class c13 {

public:

    int ival;

};

(d) class c14 {

public:

    c14( int, int=0 );

    bool operator==();

    bool operator!=();

    // ...

}

Как перегрузить имя функции

В C++ двум или более функциям может быть дано одно и то же имя при условии, что их списки параметров различаются либо числом параметров, либо их типами. В данном примере мы объявляем перегруженную функцию max():

int max ( int, int );

int max( const vector<int> & );

int max( const matrix & );

Для каждого перегруженного объявления требуется отдельное определение функции max() с соответствующим списком параметров.

Если в некоторой области видимости имя функции объявлено более одного раза, то второе (и последующие) объявление интерпретируется компилятором так:

· если списки параметров двух функций отличаются числом или типами параметров, то функции считаются перегруженными:

// перегруженные функции

void print( const string & );

void print( vector<int> & );

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

// объявления одной и той же функции

void print( const string &str );

void print( const string & );

Имена параметров при сравнении объявлений во внимание не принимаются;

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

unsigned int max( int i1, int i2 );

int max( int i1, int i2 ); // ошибка: отличаются только типы

// возвращаемых значений

Перегруженные функции не могут различаться лишь типами возвращаемого значения;

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

// объявления одной и той же функции

int max ( int *ia, int sz );

int max ( int *ia, int = 10 );

Ключевое слово typedef

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

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

// typedef не вводит нового типа

typedef double DOLLAR;

// ошибка: одинаковые списки параметров, но разные типы

// возвращаемых значений

extern DOLLAR calc( DOLLAR );

extern int calc( double );

Спецификаторы const или volatile при подобном сравнении не принимаются во внимание. Так, следующие два объявления считаются одинаковыми:

// объявляют одну и ту же функцию

void f( int );

void f( const int );

Спецификатор const

важен только внутри определения функции: он показывает, что в теле функции запрещено изменять значение параметра. Однако аргумент, передаваемый по значению, можно использовать в теле функции как обычную инициированную переменную: вне функции изменения не видны. (Способы передачи аргументов, в частности передача по значению, обсуждаются в разделе 7.3.) Добавление спецификатора const к параметру, передаваемому по значению, не влияет на его интерпретацию. Функции, объявленной как f(int), может быть передано любое значение типа int, равно как и функции f(const int). Поскольку они обе принимают одно и то же множество значений аргумента, то приведенные объявления не считаются перегруженными. f()

можно определить как

void f( int i ) { }

или как

void f( const int i ) { }

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

Однако, если спецификатор const или volatile

применяется к параметру указательного или ссылочного типа, то при сравнении объявлений он учитывается.

// объявляются разные функции

void f( int* );

void f( const int* );

// и здесь объявляются разные функции

void f( int& );

void f( const int& );

Как растет вектор?

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

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

Емкость– это максимальное количество элементов, которое может вместить контейнер без дополнительного выделения памяти. (Емкостью обладают только те контейнеры, в которых элементы хранятся в непрерывной области памяти, – vector, deque и string. Для контейнера list это понятие не определено.) Емкость может быть получена с помощью функции capacity(). Размер – это реальное количество элементов, хранящихся в данный момент в контейнере. Размер можно получить с помощью функции size(). Например:

#include <vector>

#include <iostream>

int main()

{

vector< int > ivec;

cout << "ivec: размер: " << ivec.size()

<< " емкость: " << ivec.capacity() << endl;

for ( int ix = 0; -ix < 24; ++ix ) {

ivec.push_back( ix );

cout << "ivec: размер: " << ivec.size()

<< " емкость: " << ivec.capacity() << endl;

}

<
}

В реализации Rogue Wave и размер, и емкость ivec сразу после определения равны 0. После вставки первого элемента размер становится равным 1, а емкость – 256. Это значит, что до первого дополнительного выделения памяти в ivec

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

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

Тип данных	Размер в байтах	Емкость после первой вставки
int	4	256
double	8	128
простой класс #1	12	85
string	12	85
большой простой класс	8000	1
большой сложный класс	8000	1

Итак, в реализации Rogue Wave при первой вставке выделяется точно или примерно 1024 байта. После каждого дополнительного выделения памяти емкость удваивается. Для типа данных, имеющего большой размер, емкость мала, и увеличение памяти с копированием старых элементов происходит часто, вызывая потерю эффективности. (Говоря о сложных классах, мы имеем в виду класс, обладающий копирующим конструктором и операцией присваивания.) В таблице 6.2 показано время в секундах, необходимое для вставки десяти миллионов элементов разного типа в список и в вектор. Таблица 6.3 показывает время, требуемое для вставки 10 000 элементов (вставка элементов большего размера оказалась слишком медленной).

Таблица 6.2. Время в секундах для вставки 10 000 000 элементов

Тип данных	List	Vector
int	10.38	3.76
double	10.72	3.95
простой класс	12.31	5.89
string	14.42	11.80

Таблица 6.3. Время в секундах для вставки 10 000 элементов

Тип данных	List	Vector
большой простой класс	0.36	2.23
большой сложный класс	2.37	6.70

<

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

Вставка элемента как в список, так и в вектор, требует вызова копирующего конструктора, если он определен. (Копирующий конструктор инициализирует один объект значением другого. В разделе 2.2 приводится начальная информация, а в разделе 14.5 о таких конструкторах рассказывается подробно). Это и объясняет различие в поведении простых и сложных объектов при вставке в контейнер. Объекты простого класса вставляются побитовым копированием (биты одного объекта пересылаются в биты другого), а для строк и сложных классов это производится вызовом копирующего конструктора.

Вектор должен вызывать их для каждого элемента при перераспределении памяти. Более того, освобождение памяти требует работы деструкторов для всех элементов (понятие деструктора вводится в разделе 2.2). Чем чаще происходит перераспределение памяти, тем больше времени тратится на эти дополнительные вызовы конструкторов и деструкторов.

Конечно, одним из решений может быть переход от вектора к списку, когда эффективность вектора становится слишком низкой. Другое, более предпочтительное решение состоит в том, чтобы хранить в векторе не объекты сложного класса, а указатели на них. Такая замена позволяет уменьшить затраты времени на 10 000 вставок с 6.70 секунд до 0.82 секунды. Почему? Емкость возросла с 1 до 256, что существенно снизило частоту перераспределения памяти. Кроме того, копирующий конструктор и деструктор не вызываются больше для каждого элемента при копировании прежнего содержимого вектора.

Функция reserve()

позволяет программисту явно задать емкость контейнера[11]. Например:

int main() {

    vector< string > svec;

    svec.reserve( 32 ); // задает емкость равной 32

    // ...

<

}

svec

получает емкость 32 при размере 0. Однако эксперименты показали, что любое изменение начальной емкости для вектора, у которого она по умолчанию отлична от 1, ведет к снижению производительности. Так, для векторов типа string и double

увеличение емкости с помощью reserve() дало худшие показатели. С другой стороны, увеличение емкости для больших сложных типов дает значительный рост производительности, как показано в таблице 6.4.

Таблица 6.4. Время в секундах для вставки 10 000 элементов при различной емкости*

Емкость	Время в секундах
1 по умолчанию	670
4,096	555
8,192	444
10,000	222
*Сложный класс размером 8000 байт с конструктором копирования и деструктором

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

Упражнение 6.2

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

Упражнение 6.3

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

Упражнение 6.4

Объясните, какой из типов контейнера – вектор или список – больше подходит для приведенных примеров (во всех случаях происходит вставка неизвестного заранее числа элементов):.

(a) Целые числа

(b) Указатели на большие сложные объекты

(c) Большие сложные объекты

Класс bitset

Таблица 4.4. Операции с классом bitset

Операция	Значение	Использование
test(pos)	Бит pos равен 1?	a.test(4)
any()	Хотя бы один бит равен 1?	a.any()
none()	Ни один бит не равен 1?	a.none()
count()	Количество битов, равных 1	a.count()
size()	Общее количество битов	a.size()
[pos]	Доступ к биту pos	a[4]
flip()	Изменить значения всех	a.flip()
flip(pos)	Изменить значение бита pos	a.flip(4)
set()	Выставить все биты в 1	a.set()
set(pos)	Выставить бит pos в 1	a.set(4)
reset()	Выставить все биты в 0	a.reset()
reset(pos)	Выставить бит pos в 0	a.reset(4)

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

упрощает работу с битовым вектором. Вот какое выражение нам приходилось писать в предыдущем разделе для того, чтобы “взвести” 27-й бит:

quiz1 |= 1<<27;

При использовании bitset то же самое мы можем сделать двумя способами:

quiz1[27] = 1;

или

quiz1.set(27);

(В нашем примере мы не используем нулевой бит, чтобы сохранить “естественную” нумерацию. На самом деле, нумерация битов начинается с 0.)

Для использования класса bitset

необходимо включить заголовочный файл:

#include <bitset>

Объект типа bitset

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

bitset<32> bitvec;

Это определение задает объект bitset, содержащий 32 бита с номерами от 0 до 31. Все биты инициализируются нулем. С помощью функции any()

можно проверить, есть ли в векторе единичные биты. Эта функция возвращает true, если хотя бы один бит отличен от нуля. Например:

bool is_set = bitvec.any();

Переменная is_set

получит значение false, так как объект bitset по умолчанию инициализируется нулями. Парная функция none()

возвращает true, если все биты равны нулю:

bool is_not_set = bitvec.none();

Изменить значение отдельного бита можно двумя способами: воспользовавшись функциями set() и reset() или индексом. Так, следующий цикл выставляет в 1 каждый четный бит:

for ( int index=0; index<32; ++index )

if ( index % 2 == 0 )

bitvec[ index ] = 1;

Аналогично существует два способа проверки значений каждого бита – с помощью функции test() и с помощью индекса. Функция () возвращает true, если соответствующий бит равен 1, и false в противном случае. Например:

if ( bitvec.test( 0 ))

// присваивание bitvec[0]=1 сработало!;

Значения битов с помощью индекса проверяются таким образом:

cout << "bitvec: включенные биты:\n\t";

for ( int index = 0; index < 32; ++-index )

if ( bitvec[ index ] )

cout << index << " ";

cout << endl;

Следующая пара операторов демонстрирует сброс первого бита двумя способами:

bitvec.reset(0);

bitvec[0] = 0;

Функции set() и reset()

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

// сброс всех битов

bitvec.reset();

if (bitvec.none() != true)

// что-то не сработало

// установить в 1 все биты вектора bitvec

if ( bitvec.any() != true )

// что-то опять не сработало

Функция flip()

меняет значение отдельного бита или всего битового вектора:

bitvec.f1ip( 0 ); // меняет значение первого бита

bitvec[0].flip(); // тоже меняет значение первого бита

bitvec.flip(); // меняет значения всех битов

Существуют еще два способа определить объект типа bitset. Оба они дают возможность проинициализировать объект определенным набором нулей и единиц. Первый способ – явно задать целое беззнаковое число как аргумент конструктору. Начальные N позиций битового вектора получат значения соответствующих двоичных разрядов аргумента. Например:

bitset< 32 > bitvec2( Oxffff );

инициализирует bitvec2

следующим набором значений:

00000000000000001111111111111111

В результате определения

bitset< 32 > bitvec3( 012 );

у bitvec3

окажутся ненулевыми биты на местах 1 и 3:

00000000000000000000000000001010

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

// эквивалентно bitvec3

string bitva1( "1010" );

bitset< 32 > bitvec4( bitval );

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

// подстрока с шестой позиции длиной 4: 1010

string bitval ( "1111110101100011010101" );

bitset< 32 > bitvec5( bitval, 6, 4 );

Мы получаем то же значение, что и для bitvec3 и bitvec4. Если опустить третий параметр, подстрока берется до конца исходной строки:

// подстрока с шестой позиции до конца строки: 1010101

string bitva1( "1111110101100011010101" );

bitset< 32 > bitvec6( bitval, 6 );

Класс bitset

предоставляет две функции-члена для преобразования объекта bitset в другой тип. Для трансформации в строку, состоящую из символов нулей и единиц, служит функция to_string():

string bitva1( bitvec3.to_string() );

Вторая функция, to_long(), преобразует битовый вектор в его целочисленное представление в виде unsigned long, если, конечно, оно помещается в unsigned long. Это видоизменение особенно полезно, если мы хотим передать битовый вектор функции на С или С++, не пользующейся стандартной библиотекой.

К объектам типа bitset

можно применять побитовые операции. Например:

bitset<32> bitvec7 = bitvec2 & bitvec3;

Объект bitvec7

инициализируется результатом побитового И двух битовых векторов bitvec2 и bitvec3.

bitset<32> bitvec8 = bitvec2 | bitvec3;

Здесь bitvec8

инициализируется результатом побитового ИЛИ векторов bitvec2 и bitvec3. Точно так же поддерживаются и составные операции присваивания и сдвига.

Упражнение 4.15

Допущены ли ошибки в приведенных определениях битовых векторов?

(a) bitset<64> bitvec(32);

(b) bitset<32> bv( 1010101 );

(c) string bstr; cin >> bstr; bitset<8>bv( bstr );

(d) bitset<32> bv; bitset<16> bvl6( bv );

Упражнение 4.16

Допущены ли ошибки в следующих операциях с битовыми векторами?

extern void bitstring(const char*);

bool bit_on (unsigned long, int);

bitset<32> bitvec;

(a) bitsting( bitvec.to_string().c_str() );

(b) if ( bit_on( bitvec.to_1ong(), 64 )) ...

(c) bitvec.f1ip( bitvec.count() );

Упражнение 4.17

Дана последовательность: 1,2,3,5,8,13,21. Каким образом можно инициализировать объект bitset<32> для ее представления? Как присвоить значения для представления этой последовательности пустому битовому вектору? Напишите вариант инициализации и вариант с присваиванием значения каждому биту.

Класс complex

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

#include <comp1ex>

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

2 + 3i

где 2 – действительная часть, а 3i – мнимая. Вот примеры определений объектов типа complex:

// чисто мнимое число: 0 + 7-i

comp1ex< double > purei( 0, 7 );

// мнимая часть равна 0: 3 + Oi

comp1ex< float > rea1_num( 3 );

// и вещественная, и мнимая часть равны 0: 0 + 0-i

comp1ex< long double > zero;

// инициализация одного комплексного числа другим

comp1ex< double > purei2( purei );

Поскольку complex, как и vector, является шаблоном, мы можем конкретизировать его типами float, double и long double, как в приведенных примерах. Можно также определить массив элементов типа complex:

complex< double > conjugate[ 2 ] = {

complex< double >( 2, 3 ),

complex< double >( 2, -3 )

};

Вот как определяются указатель и ссылка на комплексное число:

complex< double > *ptr = &conjugate[0];

complex< double > &ref = *ptr;

Комплексные числа можно складывать, вычитать, умножать, делить, сравнивать, получать значения вещественной и мнимой части. (Более подробно мы будем говорить о классе complex в разделе 4.6.)

Класс для обработки параметров командной строки

Чтобы не перегружать функцию main()

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

extern int parse_options( int arg_count, char *arg_vector );

int main( int argc, char *argv[] ) {

// ...

int option_status;

option_status = parse_options( argc, argv );

// ...

}

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

Данные-члены класса представляют собой параметры, заданные пользователем в командной строке. Набор открытых встроенных функций-членов позволяет получать их значения. Конструктор инициализирует параметры значениями по умолчанию. Функция-член получает argc и argv в качестве аргументов и обрабатывает их:

#include <vector>

#include <string>

class CommandOpt {

public:

CommandOpt() : _limit( -1 ), _debug_on( false ) {}

int parse_options( int argc, char *argv[] );

string out_file() { return _out_file; }

bool debug_on() { return _debug_on; }

int files() { return _file_names.size(); }

string& operator[]( int ix );

private:

inline void usage( int exit_value = 0 );

bool _debug_on;

int _limit;

string _out_file;

vector<string> _file_names;

static const char *const program_name;

static const char *const program_version;

};

Так выглядит модифицированная функция main():[18]

#include "CommandOpt.h"

int main( int argc, char "argv[] ) {

// ...

CommandOpt com_opt;

int option_status;

opttion_status = com_opt. parse_options (argc, argv);

// ...

}

Упражнение 7.15

Добавьте обработку опций -t

(включение таймера) и -b

(задание размера буфера bufsize). Не забудьте обновить usage(). Например:

prog -t -b 512 dataO

Упражнение 7.16

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

Упражнение 7.17

Наша реализация не может различить лишний пробел между дефисом и опцией:

prog - d dataO

Модифицируйте программу так, чтобы она распознавала подобную ошибку и сообщала о ней.

Упражнение 7.18

В нашей программе не предусмотрен случай, когда опции -l или -o

задаются несколько раз. Реализуйте такую возможность. Какова должна быть стратегия при разрешении конфликта?

Упражнение 7.19

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

Упражнение 7.20

Добавьте поддержку опций, начинающихся со знака плюс (+), обеспечив обработку +s и +pt, а также +sp и +ps. Предположим, что +s

включает строгую проверку синтаксиса, а +p допускает использование устаревших конструкций. Например:

prog +s +p -d -b 1024 dataO

Класс массива с множественным наследованием

Определим отсортированный массив с контролем выхода за границы. Для этого можно применить множественное наследование от Array_RC и Array_Sort. Вот как выглядит наша реализация (напомним еще раз, что мы ограничились тремя конструкторами и оператором взятия индекса). Определение находится в заголовочном файле Array_RC_S.h:

#ifndef ARRAY_RC_S_H

#define ARRAY_RC_S_H

#include "Array_S.C"

#include "Array_RC.C"

template <class Type>

class Array_RC_S : public Array_RC<Type>,

public Array_Sort<Type>

{

public:

Array_RC_S( int sz = Array<Type>::ArraySize )

: Array<Type>( sz )

{ clear_bit(); }

Array_RC_S( const Array_RC_S &rca )

: Array<Type>( rca )

{ sort( 0,Array<Type>::_size-1 ); clear_bit(); }

Array_RC_S( const Type* arr, int sz )

: Array<Type>( arr, sz )

{ sort( 0,Array<Type>::_size-1 ); clear_bit(); }

Type& operator[]( int index )

{

set_bit();

return Array_RC<Type>::operator[]( index );

}

};

#endif

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

экземплярам отдается предпочтение по сравнению с экземплярами, унаследованными из виртуального базового класса через Array_RC (см. раздел 18.5.4). Таким образом, при виртуальном наследовании неквалифицированный вызов find()

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

}

Вот что печатает программа для класса, конкретизированного типом string (теперь ошибка выхода за границы массива перехватывается):

конкретизация класса Array_Sort<string>

try_array: начальные значения массива

( 7 )< Eeyore, Gopher, Heffalump, Owl, Piglet, Pooh

       Tigger >

try_array: после присваиваний

( 7 )< Eeyore, Gopher, Owl, Piglet, Pooh, Pooh

       Pooh >

try_array: почленная инициализация

( 7 )< Eeyore, Gopher, Owl, Piglet, Pooh, Pooh

       Pooh >

try_array: после почленного копирования

( 7 )< Eeyore, Piglet, Owl, Piglet, Pooh, Pooh

       Pooh >

try_array: после вызова grow

( 7 )< <empty>, <empty>, <empty>, <empty>, Eeyore, Owl

       Piglet, Piglet, Pooh, Pooh, Pooh >

искомое значение: Tigger           возвращенный индекс: -1

Assertion failed: ix >= 0 && ix < size

Представленная в этой главе реализация иерархии класса Array иллюстрирует применение множественного и виртуального наследования. Детально проектирование класса массива описано в [NACKMAN94]. Однако, как правило, достаточно класса vector из стандартной библиотеки.

Упражнение 18.16

Добавьте в Array

функцию-член spy(). Она запоминает операции, примененные к объекту класса: число доступов по индексу; количество вызовов каждого члена; какой элемент искали с помощью find() и сколько было успешных поисков. Поясните свои проектные решения. Модифицируйте все подтипы Array

так, чтобы spy()

можно было использовать и для них тоже.

Упражнение 18.17

Стандартный библиотечный класс map

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

Упражнение 18.18

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

19

Класс pair

(пара) стандартной библиотеки С++ позволяет нам определить одним объектом пару значений, если между ними есть какая-либо семантическая связь. Эти значения могут быть одинакового или разного типа. Для использования данного класса необходимо включить заголовочный файл:

#inc1ude <uti1ity>

Например, инструкция

pair< string, string > author( "James", "Joyce" );

создает объект author

типа pair, состоящий из двух строковых значений.

Отдельные части пары могут быть получены с помощью членов first и second:

string firstBook;

if ( Joyce.first == "James" &&

Joyce.second == "Joyce" )

firstBook = "Stephen Hero";

Если нужно определить несколько однотипных объектов этого класса, удобно использовать директиву typedef:

typedef pair< string, string > Authors;

Authors proust( "marcel", "proust" );

Authors joyce( "James", "Joyce" );

Authors musil( "robert", "musi1" );

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

class EntrySlot;

extern EntrySlot* 1ook_up( string );

typedef pair< string, EntrySlot* > SymbolEntry;

SymbolEntry current_entry( "author", 1ook_up( "author" ));

// ...

if ( EntrySlot *it = 1ook_up( "editor" ))

{

current_entry.first = "editor";

current_entry.second = it;

}

(Мы вернемся к рассмотрению класса pair в разговоре о контейнерных типах в главе 6 и об обобщенных алгоритмах в главе 12.)

Класс string

Как мы только что видели, применение встроенного строкового типа чревато ошибками и не очень удобно из-за того, что он реализован на слишком низком уровне. Поэтому достаточно распространена разработка собственного класса или классов для представления строкового типа– чуть ли не каждая компания, отдел или индивидуальный проект имели свою собственную реализацию строки. Да что говорить, в предыдущих двух изданиях этой книги мы делали то же самое! Это порождало проблемы совместимости и переносимости программ. Реализация стандартного класса string

стандартной библиотекой С++ призвана была положить конец этому изобретению велосипедов.

Попробуем специфицировать минимальный набор операций, которыми должен обладать класс string:

· инициализация массивом символов (строкой встроенного типа) или другим объектом типа string. Встроенный тип не обладает второй возможностью;

· копирование одной строки в другую. Для встроенного типа приходится использовать функцию strcpy();

· доступ к отдельным символам строки для чтения и записи. Во встроенном массиве для этого применяется операция взятия индекса или косвенная адресация;

· сравнение двух строк на равенство. Для встроенного типа используется функция strcmp();

· конкатенация двух строк, получая результат либо как третью строку, либо вместо одной из исходных. Для встроенного типа применяется функция strcat(), однако чтобы получить результат в новой строке, необходимо последовательно задействовать функции strcpy() и strcat();

· вычисление длины строки. Узнать длину строки встроенного типа можно с помощью функции strlen();

· возможность узнать, пуста ли строка. У встроенных строк для этой цели приходится проверять два условия:

char str = 0;

//...

if ( ! str || ! *str )

return;

Класс string

стандартной библиотеки С++ реализует все перечисленные операции (и гораздо больше, как мы увидим в главе 6). В данном разделе мы научимся пользоваться основными операциями этого класса.

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

#include <string>

Вот пример строки из предыдущего раздела, представленной объектом типа string и инициализированной строкой символов:

#include <string>

string st( "Цена бутылки вина\n" );

Длину строки возвращает функция-член size() (длина не включает завершающий нулевой символ).

cout << "Длина "

     << st

     << ": " << st.size()

     << " символов, включая символ новой строки\n";

Вторая форма определения строки задает пустую строку:

string st2; // пустая строка

Как мы узнаем, пуста ли строка? Конечно, можно сравнить ее длину с 0:

if ( ! st.size() )

     // правильно: пустая

Однако есть и специальный метод empty(), возвращающий true для пустой строки и false для непустой:

if ( st.empty() )

     // правильно: пустая

Третья форма конструктора инициализирует объект типа string другим объектом того же типа:

string st3( st );

Строка st3

инициализируется строкой st. Как мы можем убедиться, что эти строки совпадают? Воспользуемся оператором сравнения (==):

if ( st == st3 )

     // инициализация сработала

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

st2 = st3; // копируем st3 в st2

Для конкатенации строк используется операция сложения (+) или операция сложения с присваиванием (+=). Пусть даны две строки:

string s1( "hello, " );

string s2( "world\n" );

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

string s3 = s1 + s2;

Если же мы хотим добавить s2 в конец s1, мы должны написать:

s1 += s2;

Операция сложения может конкатенировать объекты класса string не только между собой, но и со строками встроенного типа. Можно переписать пример, приведенный выше, так, чтобы специальные символы и знаки препинания представлялись встроенным типом, а значимые слова – объектами класса string:

const char *pc = ", ";

string s1( "hello" );

string s2( "world" );

string s3 = s1 + pc + s2 + "\n";

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

string s1;

const char *pc = "a character array";

s1 = pc; // правильно

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

char *str = s1; // ошибка компиляции

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

char *str = s1.c_str(); // почти правильно

Функция c_str()

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

Приведенный выше пример инициализации указателя char *str все еще не совсем корректен. c_str()

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

const char *

(В следующем разделе мы расскажем о ключевом слове const). Правильный вариант инициализации выглядит так:

const char *str = s1.c_str(); // правильно

К отдельным символам объекта типа string, как и встроенного типа, можно обращаться с помощью операции взятия индекса. Вот, например, фрагмент кода, заменяющего все точки символами подчеркивания:

string str( "fa.disney.com" );

int size = str.size();

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

if ( str[ ix ] == '.' )

str[ ix ] = '_';

Вот и все, что мы хотели сказать о классе string прямо сейчас. На самом деле, этот класс обладает еще многими интересными свойствами и возможностями. Скажем, предыдущий пример реализуется также вызовом одной-единственной функции replace():

replace( str.begin(), str.end(), '.', '_' );

replace() – один из обобщенных алгоритмов, с которыми мы познакомились в разделе 2.8 и которые будут детально разобраны в главе 12. Эта функция пробегает диапазон от begin() до end(), которые возвращают указатели на начало и конец строки, и заменяет элементы, равные третьему своему параметру, на четвертый.

Упражнение 3.12

Найдите ошибки в приведенных ниже операторах:

(a) char ch = "The long and winding road";

(b) int ival = &ch;

(c) char *pc = &ival;

(d) string st( &ch );

(e) pc = 0; (i) pc = '0';

(f) st = pc; (j) st = &ival;

(g) ch = pc[0]; (k) ch = *pc;

(h) pc = st; (l) *pc = ival;

Упражнение 3.13

Объясните разницу в поведении следующих операторов цикла:

while ( st++ )

++cnt;

while ( *st++ )

++cnt;

Упражнение 3.14

Даны две семантически эквивалентные программы. Первая использует встроенный строковый тип, вторая – класс string:

// ***** Реализация с использованием C-строк *****

#include <iostream>

#include <cstring>

int main()

{

    int errors = 0;

    const char *pc = "a very long literal string";

    for ( int ix = 0; ix < 1000000; ++ix )

    {

          int len = strlen( pc );

          char *pc2 = new char[ len + 1 ];

          strcpy( pc2, pc );

          if ( strcmp( pc2, pc ))

               ++errors;

          delete [] pc2;

    }

    cout << "C-строки: "

         << errors << " ошибок.\n";

}

// ***** Реализация с использованием класса string *****

#include <iostream>

#include <string>

int main()

{

    int errors = 0;

    string str( " a very long literal string" );

    for ( int ix = 0; ix < 1000000; ++ix )

    {

          int len = str.size();

          string str2 = str;

          if ( str != str2 )

    }

    cout << "класс string: "

         << errors << " ошибок.\n;

}

Что эти программы делают?

Оказывается, вторая реализация выполняется в два раза быстрее первой. Ожидали ли вы такого результата? Как вы его объясните?

Упражнение 3.15

Могли бы вы что-нибудь улучшить или дополнить в наборе операций класса string, приведенных в последнем разделе? Поясните свои предложения.

Класс type_info

Точное определение класса type_info

зависит от реализации, но некоторые его характерные черты остаются неизменными в любой программе на C++:

class type_info {

// ïðåäñòàâëåíèå çàâèñèò îò ðåàëèçàöèè

private:

type_info( const type_info& );

type_info& operator= ( const type_info& );

public:

virtual ~type_info();

int operator==( const type_info& );

int operator!=( const type_info& );

const char * name() const;

};

Поскольку копирующие конструктор и оператор присваивания – закрытые члены класса type_info, то пользователь не может создать его объекты в своей программе:

#include <typeinfo>

type_info t1; // îøèáêà: íåò êîíñòðóêòîðà ïî óìîë÷àíèþ

// îøèáêà: êîïèðóþùèé êîíñòðóêòîð çàêðûò

type_info t2 (typeid( unsigned int ) );

Единственный способ создать объект класса type_info – воспользоваться оператором typeid.

В классе определены также операторы сравнения. Они позволяют сравнивать два объекта type_info, а следовательно, и результаты, возвращенные двумя операторами typeid. (Мы говорили об этом в предыдущем подразделе.)

typeid( re ) == typeid( manager ) // èñòèííî

typeid( *pe ) != typeid( employee ) // ложно

Функция name()

возвращает C-строку с именем типа, представленного объектом type_info. Этой функцией можно пользоваться в программах следующим образом:

#include <typeinfo>

int main() {

   employee *pe = new manager;

   // ïå÷àòàåò: "manager"

   cout << typeid( *pe ).name() << endl;

}

Для работы с функцией-членом name()

нужно включить заголовочный файл <typeinfo>.

Имя типа – это единственная информация, которая гарантированно возвращается всеми реализациями C++, при этом используется функция-член name() класса type_info. В начале этого раздела упоминалось, что поддержка RTTI зависит от реализации и иногда в классе type_info

бывают дополнительные функции-члены. Чтобы узнать, каким образом обеспечивается поддержка RTTI в вашем компиляторе, обратитесь к справочному руководству по нему. Кроме того, можно получить любую информацию, которую компилятор знает о типе, например:

· список функций-членов класса;

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

Одним из способов расширения поддержки RTTI является включение дополнительной информации в класс, производный от type_info. Поскольку в классе type_info

есть виртуальный деструктор, то оператор dynamic_cast позволяет выяснить, имеется ли некоторое конкретное расширение RTTI. Предположим, что некоторый компилятор предоставляет расширенную поддержку RTTI посредством класса extended_type_info, производного от type_info. С помощью оператора dynamic_cast

программа может узнать, принадлежит ли объект типа type_info, возвращенный оператором typeid, к типу extended_type_info. Если да, то пользоваться расширенной поддержкой RTTI разрешено.

#include <typeinfo>

// Файл typeinfo содержит определение типа extended_type_info

void func( employee* p )

{

   // понижающее приведение типа type_info* к extended_type_info*

   if ( eti *eti_p = dynamic_cast<eti *>( &typeid( *p ) ) )

   {

      // если dynamic_cast завершается успешно,

      // можно пользоваться информацией из extended_type_info через eti_p

   }

   else

   {

      // если dynamic_cast завершается неудачно,

      // можно пользоваться только стандартным type_info

   }

<

}

Если dynamic_cast

завершается успешно, то оператор typeid вернет объект класса extended_type_info, т.е. компилятор обеспечивает расширенную поддержку RTTI, чем программа может воспользоваться. В противном случае допустимы только базовые средства RTTI.

Упражнение 19.1

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

class X { ... };

class A { ... };

class B : public A { ... };

class C : public B { ... };

class D : public X, public C { ... };

Какие из данных операторов dynamic_cast

завершатся неудачно?

(a) D *pd = new D;

A *pa = dynamic_cast< A* > ( pd );

(b) A *pa = new C;

C *pc = dynamic_cast< C* > ( pa );

D *pd = dynamic_cast< D* > ( pb );

(d) A *pa = new D;

X *px = dynamic_cast< X* > ( pa );

Упражнение 19.2

Объясните, когда нужно пользоваться оператором dynamic_cast вместо виртуальной функции?

Упражнение 19.3

Пользуясь иерархией классов из упражнения 19.1, перепишите следующий фрагмент так, чтобы в нем использовался ссылочный вариант dynamic_cast для преобразования *pa в тип D&:

if ( D *pd = dynamic_cast< D* >( pa ) ) {

// использовать члены D

}

else {

// использовать члены A

}

Упражнение 19.4

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

class X { ... };

class A { ... };

class B : public A { ... };

class C : public B { ... };

class D : public X, public C { ... };

Какое имя типа будет напечатано в каждом из следующих случаев:

(a) A *pa = new D;

    cout << typeid( pa ).name() << endl;

(b) X *px = new D;

    cout << typeid( *px ).name() << endl;

(c) C obj;

    A& ra = cobj;

    cout << typeid( &ra ).name() << endl;

(d) X *px = new D;

    A& ra = *px;

cout << typeid( ra ).name() << endl;

Класс vector

Использование класса vector

(см. раздел 2.8) является альтернативой применению встроенных массивов. Этот класс предоставляет гораздо больше возможностей, поэтому его использование предпочтительней. Однако встречаются ситуации, когда не обойтись без массивов встроенного типа. Одна из таких ситуаций– обработка передаваемых программе параметров командной строки, о чем мы будем говорить в разделе 7.8. Класс vector, как и класс string, является частью стандартной библиотеки С++.

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

#include <vector>

Существуют два абсолютно разных подхода к использованию вектора, назовем их идиомой массива и идиомой STL. В первом случае объект класса vector

используется точно так же, как массив встроенного типа. Определяется вектор заданной размерности:

vector< int > ivec( 10 );

что аналогично определению массива встроенного типа:

int ia[ 10 ];

Для доступа к отдельным элементам вектора применяется операция взятия индекса:

void simp1e_examp1e()

{

const int e1em_size = 10;

vector< int > ivec( e1em_size );

int ia[ e1em_size ];

for ( int ix = 0; ix < e1em_size; ++ix )

ia[ ix ] = ivec[ ix ];

// ...

}

Мы можем узнать размерность вектора, используя функцию size(), и проверить, пуст ли вектор, с помощью функции empty(). Например:

void print_vector( vector<int> ivec )

{

if ( ivec.empty() )

return;

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

cout << ivec[ ix ] << ' ';

}

Элементы вектора инициализируются значениями по умолчанию. Для числовых типов и указателей таким значением является 0. Если в качестве элементов выступают объекты класса, то инициатор для них задается конструктором по умолчанию (см. раздел 2.3). Однако инициатор можно задать и явно, используя форму:

vector< int > ivec( 10, -1 );

Все десять элементов вектора будут равны -1.

Массив встроенного типа можно явно инициализировать списком:

int ia[ 6 ] = { -2, -1, О, 1, 2, 1024 };

Для объекта класса vector

аналогичное действие невозможно. Однако такой объект может быть инициализирован с помощью массива встроенного типа:

// 6 элементов ia копируются в ivec

vector< int > ivec( ia, ia+6 );

Конструктору вектора ivec

передаются два указателя – указатель на начало массива ia и на элемент, следующий за последним. В качестве списка начальных значений допустимо указать не весь массив, а некоторый его диапазон:

// копируются 3 элемента: ia[2], ia[3], ia[4]

vector< int > ivec( &ia[ 2 ], &ia[ 5 ] );

Еще одним отличием вектора от массива встроенного типа является возможность инициализации одного объекта типа vector другим и использования операции присваивания для копирования объектов. Например:

vector< string > svec;

void init_and_assign()

{

    // один вектор инициализируется другим

    vector< string > user_names( svec );

    // ...

    // один вектор копируется в другой

    svec = user_names;

}

Говоря об идиоме STL[6], мы подразумеваем совсем другой подход к использованию вектора. Вместо того чтобы сразу задать нужный размер, мы определяем пустой вектор:

vector< string > text;

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

string word;

while ( cin >> word ) {

text.push_back( word );

// ...

}

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

cout << "считаны слова: \n";

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

cout << text[ ix ] << ' ';

cout << endl;

более типичным в рамках данной идиомы будет использование итераторов:

cout << "считаны слова: \n";

for ( vector<string>::iterator it = text.begin();

it != text.end(); ++it )

cout << *it << ' ';

<

cout << endl;

Итератор – это класс стандартной библиотеки, фактически являющийся указателем на элемент массива.

Выражение

*it;

разыменовывает итератор и дает сам элемент вектора. Инструкция

++it;

сдвигает указатель на следующий элемент. Не нужно смешивать эти два подхода. Если следовать идиоме STL при определении пустого вектора:

vector<int> ivec;

будет ошибкой написать:

ivec[0] = 1024;

У нас еще нет ни одного элемента вектора ivec; количество элементов выясняется с помощью функции size().

Можно допустить и противоположную ошибку. Если мы определили вектор некоторого размера, например:

vector<int> ia( 10 );

то вставка элементов увеличивает его размер, добавляя новые элементы к существующим. Хотя это и кажется очевидным, тем не менее,

начинающий программист вполне мог бы написать:

const int size = 7;

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

vector< int > ivec( size );

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

ivec.push_back( ia[ ix ] );

Имелась в виду инициализация вектора ivec

значениями элементов ia, вместо чего получился вектор ivec размера 14.

Следуя идиоме STL, можно не только добавлять, но и удалять элементы вектора. (Все это мы рассмотрим подробно и с примерами в главе 6.)

Упражнение 3.24

Имеются ли ошибки в следующих определениях?

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

(a) vector< vector< int > > ivec;

(b) vector< int > ivec = { 0, 1, 1, 2, 3, 5, 8 };

(c) vector< int > ivec( ia, ia+7 );

(d) vector< string > svec = ivec;

(e) vector< string > svec( 10, string( "null" ));

Упражнение 3.25

Реализуйте следующую функцию:

bool is_equa1( const int*ia, int ia_size,

const vector<int> &ivec );

Функция is_equal()

сравнивает поэлементно два контейнера. В случае разного размера контейнеров “хвост” более длинного в расчет не принимается. Понятно, что, если все сравниваемые элементы равны, функция возвращает true, если отличается хотя бы один – false. Используйте итератор для перебора элементов. Напишите функцию main(), обращающуюся к is_equal().

Классы

Механизм классов в C++ позволяет пользователям определять собственные типы данных. По этой причине их часто называют пользовательскими типами. Класс может наделять дополнительной функциональностью уже существующий тип. Так, например, IntArray, введенный в главе 2, предоставляет больше возможностей, чем тип “массив int”. С помощью классов можно создавать абсолютно новые типы, например Screen

(экран) или Account

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

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

Далее в этой главе мы познакомимся с особым видом членов класса– статическими членами. Мы расскажем также, как можно использовать указатели на члены и функции-члены класса, и рассмотрим объединения, представляющие собой специализированный вид класса для хранения объектов разных типов в одной области памяти. Завершается глава обсуждением области видимости класса и описанием правил разрешения имен в этой области; затрагиваются такие понятия, как вложенные классы, классы-члены пространства имен и локальные классы.

Классы как члены пространства имен A

Представленные до сих пор классы определены в области видимости глобального пространства имен. Но их можно определять и в объявленных пользователем пространствах. Имя класса, определенного таким образом, доступно только в области видимости этого пространства, т.е. оно не конфликтует с именами, объявленными в других пространствах имен. Например:

namespace cplusplus_primer {

class Node { /* ... */ };

}

namespace DisneyFeatureAnimation {

class Node { /* ... */ };

}

Node *pnode; // ошибка: Node не видно в глобальной области видимости

// правильно: объявляет nodeObj как объект

// квалифицированного типа DisneyFeatureAnimation::Node

DisneyFeatureAnimation::Node nodeObj;

// using-объявление делает Node видимым в глобальной области видимости

using cplusplus_primer::Node;

Node another; // cplusplus_primer::Node

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

// --- primer.h ---

namespace cplusplus_primer {

class List {

// ...

private:

class ListItem {

public:

void check_status();

int action();

// ...

};

}

// --- primer.C ---

#include "primer.h"

namespace cplusplus_primer {

// правильно: check_status() определено в том же пространстве имен,

// что и List

void List::ListItem::check_status() { }

}

// правильно: action() определена в глобальной области видимости

// в пространстве имен, объемлющем определение класса List

// Имя члена квалифицировано именем пространства

<
int cplusplus_primer::List::ListItem::action() { }

Члены вложенного класса ListItem

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

Как происходит разрешение имени в определении члена, которое находится в объявленном пользователем пространстве? Например, как будет разрешено someVal:

int cplusplus_primer::List::ListItem::action() {

int local = someVal;

// ...

}

Сначала просматриваются локальные области видимости в определении функции-члена, затем поиск продолжается в области видимости ListItem, затем – в области видимости List. До этого момента все происходит так же, как в процессе разрешения имен, описанном в разделе 13.10. Далее просматриваются объявления из пространства cplusplus_primer и наконец объявления в глобальной области видимости, причем во внимание принимаются только те, которые расположены до определения функции-члена action():

// --- primer.h ---

namespace cplusplus_primer {

   class List {

      // ...

   private:

      class ListItem {

      public:

         int action();

         // ...

      };

   };

   const int someVal = 365;

}

// --- primer.C ---

#include "primer.h"

namespace cplusplus_primer {

   int List::ListItem::action() {

      // правильно: cplusplus_primer::someVal

      int local = someVal;

      // ошибка: calc() еще не объявлена

      double result = calc( local );

      // ...

   }

   double calc(int) { }

   // ...

}

Определение пространства имен cplusplus_primer не является непрерывным. Определения класса List и объекта someVal

размещены в первом его разделе, который находится в заголовочном файле primer.h. Определение функции calc()

появляется в определении пространства имен, расположенном в файле реализации primer.C. Использование calc()

внутри action()

ошибочно, так как она объявлена после использования. Если calc() – часть интерфейса cplusplus_primer, ее следовало бы объявить в той части данного пространства, которая находится в заголовочном файле:

// --- primer.h ---

namespace cplusplus_primer {

   class List {

      // ...

   }

   const int someVal = 365;

   double calc(int);

}

Если же calc()

используется только в action() и не является частью интерфейса пространства имен, то ее нужно объявить перед action(), чтобы можно было ссылаться на нее внутри определения action().

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

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

cplusplus_primer::List::ListItem::action()

Квалификаторы cplusplus_primer::List::ListItem::

записаны в порядке, обратном тому, в котором просматриваются имена областей видимости классов и пространств имен. Сначала поиск ведется в области ListItem, затем продолжается в объемлющем классе List и наконец в пространстве cplusplus_primer, предшествующем той области, в которой находится определение action(). Во время поиска в любой области видимости класса просматриваются все объявления членов, а в любом пространстве имен – только те объявления, которые встречались перед определением члена.

Класс, определенный в области видимости пространства имен, потенциально виден во всей программе. Если заголовочный файл primer.h включен в несколько исходных файлов, то имя cplusplus_primer::List

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

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

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

Упражнение 13.22

Используя класс iStack, определенный в упражнении 13.21, объявите классы исключений pushOnFull и popOnEmpty как члены пространства имен LibException:

namespace LibException {

class pushOnFull{ };

class popOnEmpty{ };

}

а сам iStack – членом пространства имен Container. Модифицируйте соответствующим образом определение данного класса и его функций-членов, а также определение main().

Когда использовать указатель this

Наша функция main()

вызывает функции-члены класса Screen для объектов myScreen и bufScreen

таким образом, что каждое действие – это отдельная инструкция. У нас есть возможность определить функции-члены так, чтобы конкатенировать их вызовы при обращении к одному и тому же объекту. Например, все вызовы внутри main() будут выглядеть так:

int main() {

// ...

myScreen.clear().move( 2, 2 ), set( '*' ). display();

bufScreen.reSize( 5, 5 ).display();

}

Именно так интуитивно представляется последовательность операций с экраном: очистить экран myScreen, переместить курсор в позицию (2,2), записать в эту позицию символ '*' и вывести результат.

Операторы доступа “точка” и “стрелка” левоассоциативны, т.е. их последовательность выполняется слева направо. Например, сначала вызывается myScreen.clear(), затем myScreen.move() и т.д. Чтобы myScreen.move()

можно было вызвать после myScreen.clear(), функция clear()

должна возвращать объект myScreen, для которого она была вызвана. Мы уже видели, что доступ к объекту внутри функции-члена класса производится в помощью указателя this. Вот реализация clear():

// объявление clear() находится в теле класса

// в нем задан аргумент по умолчанию bkground = '#'

Screen& Screen::clear( char bkground )

{ // установить курсор в левый верхний угол и очистить экран

_cursor = 0;

_screen.assign( // записать в строку

_screen.size(), // size() символов

bkground // со значением bkground

);

// вернуть объект, для которого была вызвана функция

return *this;

}

Обратите внимание, что возвращаемый тип этой функции-члена – Screen& – ссылка на объект ее же класса. Чтобы конкатенировать вызовы, необходимо также пересмотреть реализацию move() и set(). Возвращаемый тип следует изменить с void на Screen&, а в определении возвращать *this.

Аналогично функцию-член display()

можно написать так:

Screen& Screen::display()

{

typedef string::size_type idx_type;

for ( idx_type ix = 0; ix < _height; ++ix )

{ // для каждой строки

idx_type offset = _width * ix; // смещение строки

for ( idx_type iy = 0; iy < _width; ++iy )

// для каждой колонки вывести элемент

cout << _screen[ offset + iy ];

cout << endl;

}

return *this;

<
}

А вот реализация reSize():

// объявление reSize() находится в теле класса

// в нем задан аргумент по умолчанию bkground = '#'

Screen& Screen::reSize( int h, int w, char bkground )

{ // сделать высоту экрана равной h, а ширину - равной w

   // запомнить содержимое экрана

   string local(_screen);

   // заменить строку _screen

   _screen.assign(     // записать в строку

      h * w,           // h * w символов

      bkground         // со значением bkground

   );

   typedef string::size_type idx_type;

   idx_type local_pos = 0;

   // скопировать содержимое старого экрана в новый

   for ( idx_type ix = 0; ix < _height; ++ix )

   { // для каждой строки

       idx_type offset = w * ix; // смещение строки

       for ( idx_type iy = 0; iy < _width; ++iy )

          // для каждой колонки присвоить новое значение

          _screen[ offset + iy ] = local[ local_pos++ ];

   }

   _height = h;

   _width = w;

   // _cursor не меняется

   return *this;

}

Работа указателя this не исчерпывается возвратом объекта, к которому была применена функция-член. При рассмотрении copy() в разделе 13.3 мы видели и другой способ его использования:

void Screen::copy( const Screen& sobj )

{

   // если этот объект Screen и sobj - одно и то же,

   // копирование излишне

   if ( this != sobj )

   {

      // скопировать значение sobj в this

   }

}

Указатель this

хранит адрес объекта, для которого была вызвана функция-член. Если адрес, на который ссылается sobj, совпадает со значением this, то sobj и this

относятся к одному и тому же объекту, так что операция копирования не нужна. (Мы еще встретимся с этой конструкцией, когда будем рассматривать копирующий оператор присваивания в разделе 14.7.)

Упражнение 13.7

Указатель this

можно использовать для модификации адресуемого объекта, а также для его замены другим объектом того же типа. Например, функция-член assign()

класса classType

выглядит так. Можете ли вы объяснить, что она делает?

classType& classType::assign( const classType &source )

{

   if ( this != &source )

   {

      this->~classType();

      new (this) classType( source );

   }

   return *this;

}

Напомним, что ~classType – это имя деструктора. Оператор new выглядит несколько причудливо, но мы уже встречались с подобным в разделе 8.4.

Как вы относитесь к такому стилю программирования? Безопасна ли эта операция? Почему?

Когда использовать встроенные функции-члены

Обратите внимание, что определения функций home(), get(), height() и width() приведены прямо в теле класса. Такие функции называются встроенными. (Мы говорили об этом в разделе 7.6.)

Функции-члены можно объявить в теле класса встроенными и явно, поместив перед типом возвращаемого значения ключевое слово inline:

class Screen {

public:

// использование ключевого слова inline

// для объявления встроенных функций-членов

inline void home() { _cursor = 0; }

inline char get() { return _screen[_cursor]; }

// ...

};

Определения home() и get() в приведенных примерах эквивалентны. Поскольку ключевое слово inline

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

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

именем ее класса. Вот как выглядит определение функции checkRange(), квалифицированное именем Screen:

#include <iostream>

#include "screen.h"

// имя функции-члена квалифицировано именем Screen::

bool Screen::checkRange( int row, int col )

{ // проверить корректность координат

if ( row < 1 || row > _height ||

col < 1 || col > _width ) {

cerr << "Screen coordinates ( "

<< row << ", " << col

<< " ) out of bounds.\n";

return false;

}

return true;

}

Прежде чем определять функцию-член вне тела класса, необходимо объявить ее внутри тела, обеспечив ее видимость. Например, если бы перед определением функции checkRange() не был включен заголовочный файл Screen.h, то компилятор выдал бы сообщение об ошибке. Тело класса определяет полный список его членов. Этот список не может быть расширен после закрытия тела.

Обычно функции-члены, определенные вне тела класса, не делают встроенными. Но объявить такую функцию встроенной можно, если явно добавить слово inline в объявление функции внутри тела класса или в ее определение вне тела, либо сделав то и другое одновременно. В следующем примере move()

определена как встроенная функция-член класса Screen:

inline void Screen::move( int r, int c )

{ // переместить курсор в абсолютную позицию

   if ( checkRange( r, c ) ) // позиция на экране задана корректно?

   {

      int row = (r-1) * _width; // смещение начала строки

      _cursor = row + c - 1;

   }

}

Функция get(int, int)

объявляется встроенной с помощью слова inline:

class Screen {

public:

inline char get( int, int );

// объявления других функций-членов не изменяются

};

Определение функции следует после объявления класса. При этом слово inline

можно опустить:

char Screen::get( int r, int c )

{

move( r, c ); // устанавливаем _cursor

return get(); // вызываем другую функцию-член get()

}

Так как встроенные функции-члены должны быть определены в каждом исходном файле, где они вызываются, то встроенную функцию, не определенную в теле класса, следует поместить в тот же заголовочный файл, в котором определен ее класс. Например, представленные ранее определения move() и get() должны находиться в заголовочном файле Screen.h

после определения класса Screen.

Когда не надо перегружать имя функции

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

void setDate( Date&, int, int, int );

Date &convertDate( const string & );

void printDate( const Date& );

Эти функции работают с одним типом данных– классом Date, но выполняют семантически различные действия. В этом случае лексическая сложность, связанная с употреблением различных имен, проистекает из принятого программистом соглашения об обеспечении набора операций над типом данных и именования функций в соответствии с семантикой этих операций. Правда, механизм классов C++ делает такое соглашение излишним. Следовало бы сделать такие функции членами класса Date, но при этом оставить разные имена, отражающие смысл операции:

#include <string>

class Date {

public:

set( int, int, int );

Date& convert( const string & );

void print();

// ...

};

Приведем еще один пример. Следующие пять функций-членов Screen выполняют различные операции над экранным курсором, являющимся принадлежностью того же класса. Может показаться, что разумно перегрузить эти функции под общим названием move():

Screen& moveHome();

Screen& moveAbs( int, int );

Screen& moveRel( int, int, char *direction );

Screen& moveX( int );

Screen& moveY( int );

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

// функция, объединяющая moveX() и moveY()

Screen& move( int, char xy );

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

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

// какой вызов понятнее?

myScreen.home(); // мы считаем, что этот!

myScreen.move();

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

moveAbs(int, int);

moveAbs(int, int, char*);

различаются наличием третьего параметра типа char*. Если их реализации похожи и для третьего аргумента можно найти разумное значение по умолчанию, то обе функции можно заменить одной. В данном случае на роль значения по умолчанию подойдет указатель со значением 0:

move( int, int, char* = 0 );

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

Когда нельзя использовать обобщенные алгоритмы

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

Контейнер list

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

vector<string>::iterator vec_iter = vec.begin() + 7;

Такая форма вполне допустима и инициализирует vec_iter адресом восьмого элемента вектора, но запись

// ошибка: арифметические операции над итераторами

// не поддерживаются списком

list<string>::iterator list_iter = slist.begin() + 7;

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

Поскольку список не поддерживает произвольного доступа, то алгоритмы merge(), remove(), reverse(), sort() и unique()

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

· list::merge()

объединяет два отсортированных списка

· list::remove()

удаляет элементы с заданным значением

· list::remove_if()удаляет элементы, удовлетворяющие некоторому условию

· list::reverse()

переставляет элементы списка в обратном порядке

· list::sort()

сортирует элементы списка

· list::splice()

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

· list::unique()

оставляет один элемент из каждой цепочки одинаковых смежных элементов

Композиция объектов

Есть две формы композиции объектов:

композиция по значению, когда членом одного класса объявляется сам объект другого класса. Мы показывали это в исправленной реализации PeekbackStack;

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

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

Предположим, что мы решили с помощью композиции представить класс Endangered. Надо ли определить его объект непосредственно внутри ZooAnimal или сослаться на него с помощью указателя или ссылки? Сначала выясним, все ли объекты ZooAnimal

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

Если ответ на первый вопрос положительный, то, как правило, лучше применить композицию по значению. (Как правило, но не всегда, поскольку с точки зрения эффективности включение больших объектов не оптимально, особенно когда они часто копируются. В таких случаях композиция по ссылке позволит обойтись без ненужных копирований, если применять при этом подсчет ссылок и технику, называемую копированием при записи. Увеличение эффективности, правда, достигается за счет усложнения управления объектом. Обсуждение этой техники не вошло в наш вводный курс; тем, кому это интересно, рекомендуем прочитать книгу [KOENIG97], главы 6 и 7.)

Если же оказывается, что только некоторые объекты класса ZooAnimal обладают указанной характеристикой, то лучшим вариантом будет композиция по ссылке (скажем, в примере с зоопарком не имеет смысла включать в процветающие виды большой объект, описывающий виды вымирающие).

Поскольку объекта Endangered

может и не существовать, то представлять его надо указателем, а не ссылкой. (Предполагается, что нулевой указатель не адресует объект. Ссылка же всегда должна именовать определенный объект. В разделе 3.6 это различие объяснялось более подробно.)

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

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

class ZooAnimal {

public:

   // ...

   const Endangered* Endangered() const;

   void addEndangered( Endangered* );

   void removeEndangered();

   // ...

protected:

   Endangered *_endangered;

   // ...

};

Если предполагается, что наше приложение будет работать на разных платформах, то полезно инкапсулировать всю платформенно-зависимую информацию в иерархию абстрактных классов, чтобы запрограммировать платформенно-независимый интерфейс. Например, для вывода объекта ZooAnimal на дисплей UNIX-машины и ПК, можно определить иерархию классов DisplayManager:

class DisplayManager { ... };

class DisplayUNIX : public DisplayManager { ... };

class DisplayPC : public DisplayManager { ... };

Наш класс ZooAnimal не является разновидностью класса DisplayManager, но содержит экземпляр последнего посредством композиции, а не наследования. Возникает вопрос: использовать композицию по значению или по ссылке?

Композиция по значению не может представить объект DisplayManager, с помощью которого можно будет адресовать либо объект DisplayUNIX, либо объект DisplayPC. Только ссылка или указатель на объект DisplayManager позволят нам полиморфно манипулировать его подтипами. Иначе говоря, объектно-ориентированное программирование поддерживается только композицией по ссылке (подробнее см. [LIPPMAN96a].)

Теперь нужно решить, должен ли член класса ZooAnimal

быть ссылкой или указателем на DisplayManager:

·         член может быть объявлен ссылкой лишь в том случае, если при создании объекта ZooAnimal имеется реальный объект DisplayManager, который не будет изменяться по ходу выполнения программы;

·         если применяется стратегия отложенного выделения памяти, когда память для объекта DisplayManager

выделяется только при попытке вывести объект на дисплей, то объект следует представить указателем, инициализировав его значением 0;

·         если мы хотим переключать режим вывода во время выполнения, то тоже должны представить объект указателем, который инициализирован нулем. Под переключением

мы понимаем предоставление пользователю возможности выбрать один из подтипов DisplayManager в начале или в середине работы программы.

Конечно, маловероятно, что для каждого подобъекта ZooAnimal в нашем приложении будет нужен собственный подтип DisplayManager для отображения. Скорее всего мы ограничимся статическим членом в классе ZooAnimal, указывающим на объект DisplayManager.

Упражнение 18.6

Объясните, в каких случаях имеет место наследование типа, а в каких – наследование реализации:

(a) Queue : List // очередь : список

(b) EncryptedString : String // зашифрованная строка : строка

(c) Gif : FileFormat

(d) Circle : Point // окружность : точка

(e) Dqueue : Queue, List

(f) DrawableGeom : Geom, Canvas // рисуемая фигура : фигура, холст

Упражнение 18.7

Замените член IntArray в реализации PeekbackStack

(см. раздел 18.3.1) на класс deque из стандартной библиотеки. Напишите небольшую программу для тестирования.

Упражнение 18.8

Сравните композицию по ссылке с композицией по значению, приведите примеры их использования.

Конкретизация шаблона функции

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

конкретизируется дважды: один раз для массива из пяти элементов типа int, а другой – для массива из шести элементов типа double:

// определение шаблона функции min()

// с параметром-типом Type и параметром-константой size

template <typename Type, int size>

Type min( Type (&r_array)[size] )

{

Type min_val = r_array[0];

for ( int i = 1; i < size; ++i )

if ( r_array[i] < min_val )

min_val = r_array[i];

return min_val;

}

// size не задан -- ok

// size = число элементов в списке инициализации

int ia[] = { 10, 7, 14, 3, 25 };

double da[6] = { 10.2, 7.1, 14.5, 3.2, 25.0, 16.8 };

#include <iostream>

int main()

{

// конкретизация min() для массива из 5 элементов типа int

// подставляется Type => int, size => 5

int i = min( ia );

if ( i != 3 )

cout << "??oops: integer min() failed\n";

else cout << "!!ok: integer min() worked\n";

// конкретизация min() для массива из 6 элементов типа double

// подставляется Type => double, size => 6

double d = min( da );

if ( d != 3.2 )

cout << "??oops: double min() failed\n";

else cout << "!!ok: double min() worked\n";

return 0;

}

Вызов

int i = min( ia );

приводит к конкретизации следующего экземпляра функции min(), в котором Type

заменено на int, а size на 5:

int min( int (&r_array)[5] )

{

int min_val = r_array[0];

for ( int i = 1; i < 5; ++i )

if ( r_array[i] < min_val )

min_val = r_array[i];

return min_val;

}

Аналогично вызов

double d = min( da );

конкретизирует экземпляр min(), в котором Type

заменено на double, а size на 6:

В качестве формальных параметров шаблона функции используются параметр-тип и параметр-константа. Для определения фактического типа и значения константы, которые надо подставить в шаблон, исследуются фактические аргументы, переданные при вызове функции. В нашем примере для идентификации аргументов шаблона при конкретизации используются тип ia (массив из пяти int) и da

(массив из шести double). Процесс определения типов и значений аргументов шаблона по известным фактическим аргументам функции называется выведением (deduction) аргументов шаблона. (В следующем разделе мы расскажем об этом подробнее. А в разделе 10.4 речь пойдет о возможности явного задания аргументов.)

Шаблон конкретизируется либо при вызове, либо при взятии адреса функции. В следующем примере указатель pf инициализируется адресом конкретизированного экземпляра шаблона. Его аргументы определяются путем исследования типа параметра функции, на которую указывает pf:

template <typename Type, int size>

Type min( Type (&p_array)[size] ) { /* ... */ }

// pf указывает на int min( int (&)[10] )

int (*pf)(int (&)[10]) = &min;

Тип pf – это указатель на функцию с параметром типа int(&)[10], который определяет тип аргумента шаблона Type и значение аргумента шаблона size при конкретизации min(). Аргумент шаблона Type

будет иметь тип int, а значением аргумента шаблона size будет 10. Конкретизированная функция представляется как min(int(&)[10]), и указатель pf

адресует именно ее.

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

template <typename Type, int size>

Type min( Type (&r_array)[size] ) { /* ... */ }

typedef int (&rai)[10];

typedef double (&rad)[20];

void func( int (*)(rai) );

void func( double (*)(rad) );

int main() {

// ошибка: как конкретизировать min()?

func( &min );

<

}

Функция func()

перегружена и тип ее параметра не позволяет однозначно определить ни аргумент шаблона Type, ни значение аргумента шаблона size. Результатом конкретизации вызова func()

может быть любая из следующих функций:

min( int (*)(int(&)[10]) )

min( double (*)(double(&)[20]) )

Поскольку однозначно определить аргументы функции func() нельзя, взятие адреса конкретизированного шаблона в таком контексте приводит к ошибке компиляции.

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

int main() {

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

func( static_cast< double(*)(rad) >(&min) );

}

Лучше, однако, применять явное задание аргументов шаблона, как будет показано в разделе 10.4.

Конкретизация шаблона класса

В определении шаблона указывается, как следует строить индивидуальные классы, если заданы один или более фактических типов или значений. По шаблону Queue

автоматически генерируются экземпляры классов Queue с разными типами элементов. Например, если написать:

Queue<int> qi;

то из обобщенного определения шаблона автоматически создается класс Queue для объектов типа int.

Генерация конкретного класса из обобщенного определения шаблона называется конкретизацией шаблона. При такой конкретизации Queue для объектов типа int

каждое вхождение параметра Type в определении шаблона заменяется на int, так что определение класса Queue принимает вид:

template <class int>

class Queue {

public:

Queue() : front( 0 ), back ( 0 ) { }

~Queue();

int& remove();

void add( const int & );

bool is_empty() const {

return front == 0;

}

private:

QueueItem<int> *front;

QueueItem<int> *back;

};

Чтобы создать класс Queue для объектов типа string, надо написать:

Queue<string> qs;

При этом каждое вхождение Type в определении шаблона будет заменено на string. Объекты qi и qs

являются объектами автоматически созданных классов.

Каждый конкретизированный по одному и тому же шаблону экземпляр класса совершенно не зависит от всех остальных. Так, у Queue для типа int нет никаких прав доступа к неоткрытым членам того же класса для типа string.

Конкретизированный экземпляр шаблона будет иметь соответственно имя Queue<int> или Queue<string>. Части <int> и <string>, следующие за именем Queue, называются фактическими аргументами шаблона. Они должны быть заключены в угловые скобки и отделяться друг от друга запятыми. В имени конкретизируемого шаблона аргументы всегда должны задаваться явно. В отличие от аргументов шаблона функции, аргументы шаблона класса никогда не выводятся из контекста:

Queue qs; // ошибка: как конкретизируется шаблон?

Конкретизированный шаблон класса Queue

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

// типы возвращаемого значения и обоих параметров конкретизированы из

// шаблона класса Queue

extern Queue< complex<double> >

foo( Queue< complex<double> > &, Queue< complex<double> > & );

// указатель на функцию- член класса, конкретизированного из шаблона Queue

bool (Queue<double>::*pmf)() = 0;

// явное приведение 0 к указателю на экземпляр Queue

Queue<char*> *pqc = static_cast< Queue<char*>* > ( 0 );

Объекты типа класса, конкретизированного по шаблону Queue, объявляются и используются так же, как объекты обычных классов:

extern Queue<double> eqd;

Queue<int> *pqi = new Queue<int>;

Queue<int> aqi[1024];

int main() {

   int ix;

   if ( ! pqi->is_empty() )

      ix = pqi->remove();

   // ...

   for ( ix = 0; ix < 1024; ++ix )

       eqd[ ix ].add( ix );

   // ...

}

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

// объявление шаблона функции

template <class Type>

void bar( Queue<Type> &, // ссылается на обобщенный шаблон

Queue<double> & // ссылается на конкретизированный шаблон

)

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

void foo( Queue<int> &qi )

{

Queue<int> *pq = &qi;

// ...

}

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

class Matrix;

Matrix *pm; // правильно: определение класса Matrix знать необязательно

void inverse( Matrix & ); // тоже правильно

Поэтому объявление указателей и ссылок на конкретизированный шаблон класса не приводит к его конкретизации. (Отметим, что в некоторых компиляторах, написанных до принятия стандарта C++, шаблон конкретизируется при первом упоминании имени конкретизированного класса в тексте программы.) Так, в функции foo()

объявляются указатель и ссылка на Queue<int>, но это не вызывает конкретизации шаблона Queue:

// Queue<int> не конкретизируется при таком использовании в foo()

void foo( Queue<int> &qi )

{

Queue<int> *pqi = &qi;

// ...

}

Определение класса необходимо знать, когда определяется объект этого типа. В следующем примере определение obj1

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

class Matrix;

Matrix obj1; // ошибка: класс Matrix не определен

class Matrix { ... };

Matrix obj2; // правильно

Таким образом, конкретизация происходит тогда, когда определяется объект класса, конкретизированного по этому шаблону. В следующем примере определение объекта qi

приводит к конкретизации шаблона Queue<int>:

Queue<int> qi; // конкретизируется Queue<int>

Определение Queue<int>

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

Если имеется указатель или ссылка на конкретизированный шаблон, то конкретизация также производится в момент обращения к объекту, на который они ссылаются. В определенной выше функции foo() класс Queue<int>

конкретизируется в следующих случаях: когда разыменовывается указатель pqi, когда ссылка qi

используется для получения значения именуемого объекта и когда pqi или qi

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

void foo( Queue<int> &qi )

{

   Queue<int> *pqi = &qi;

   // Queue<int> конкретизируется в результате вызова функции-члена

   pqi->add( 255 );

   // ...

}

Определение Queue<int>

становится известным компилятору еще до вызова функции-члена add() из foo().

Напомним, что в определении шаблона класса Queue есть также ссылка на шаблон QueueItem:

template <class Type>

class Queue {

public:

   // ...

private:

   QueueItem<Type> *front;

   QueueItem<Type> *back;

<

};

При конкретизации

Queue типом int

члены front и back

становятся указателями на QueueItem<int>. Следовательно, конкретизированный экземпляр Queue<int>

ссылается на экземпляр QueueItem, конкретизированный типом int. Но поскольку соответствующие члены являются указателями, то QueueItem<int>

конкретизируется лишь в момент их разыменования в функциях-членах класса Queue<int>.

Наш класс QueueItem

служит вспомогательным средством для реализации класса Queue и не будет непосредственно употребляться в вызывающей программе. Поэтому пользовательская программа способна манипулировать только объектами Queue. Конкретизация шаблона QueueItem

происходит лишь в момент конкретизации шаблона класса Queue или его членов. (В следующих разделах мы рассмотрим конкретизации членов шаблона класса.)

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

template <class Type>

class QueueItem {

public:

QueueItem( Type ); // неудачное проектное решение

// ...

};

В данном определении аргумент передается по значению. Это допустимо, если QueueItem

конкретизируется встроенным типом (например, QueueItem<int>). Но если такая конкретизация производится для объемного типа (скажем, Matrix), то накладные расходы, вызванные неправильным выбором на этапе проектирования, становятся неприемлемыми. (В разделе 7.3 обсуждались вопросы производительности, связанные с передачей параметров по значению и по ссылке.) Поэтому аргумент конструктора объявляется как ссылка на константный тип:

QueueItem( const Type & );

Следующее определение приемлемо, если у типа, для которого конкретизируется QueueItem, нет ассоциированного конструктора:

template <class Type>

class QueueItem {

   // ...

public:

   // потенциально неэффективно

   QueueItem( const Type &t ) {

      item = t; next = 0;

   }

<

};

Если аргументом шаблона является тип класса с конструктором (например, string), то item

инициализируется дважды! Конструктор по умолчанию string

вызывается для инициализации item перед выполнением тела конструктора QueueItem. Затем для созданного объекта item производится почленное присваивание. Избежать такого можно с помощью явной инициализации item в списке инициализации членов внутри определения конструктора QueueItem:

template <class Type>

class QueueItem {

   // ...

public:

   // item инициализируется в списке инициализации членов конструктора

   QueueItem( const Type &t )

            : item(t) { next = 0; }

};

(Списки инициализации членов и основания для их применения обсуждались в разделе 14.5.)

Конструирование базового и производного классов

Напомним, что объект производного класса состоит из одного или более подобъектов, соответствующих базовым классам, и части, относящейся к самому производному. Например, NameQuery

состоит из подобъекта Query и объекта-члена string. Для иллюстрации поведения конструктора производного класса введем еще один член встроенного типа:

class NameQuery : public Query {

public:

// ...

protected:

bool _present;

string _name;

};

Если _present

установлен в false, то слово _name в тексте отсутствует.

Рассмотрим случай, когда в NameQuery

конструктор не определен. Тогда при определении объекта этого класса

NameQuery nq;

по очереди вызывается конструктор по умолчанию Query, а затем конструктор по умолчанию класса string

(ассоциированный с объектом _name). Член _present

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

inline NameQuery::NameQuery() { _present = false; }

Теперь при определении nq

вызываются три конструктора по умолчанию: для базового класса Query, для класса string при инициализации члена _name и для класса NameQuery.

А как передать аргумент конструктору базового класса Query? Ответить на этот вопрос можно, рассуждая по аналогии.

Для передачи одного или более аргументов конструктору объекта-члена мы используем список инициализации членов (здесь можно также задать начальные значения членам, не являющимся объектами классов; подробности см. в разделе 14.5):

inline NameQuery::

NameQuery( const string &name )

: _name( name ), _present( false )

{}

Для передачи одного или более аргументов конструктору базового класса также разрешается использовать список инициализации членов. В следующем примере мы передаем конструктору string

аргумент name, а конструктору базового класса Query – объект, адресованный указателем ploc:

inline NameQuery::

NameQuery( const string &name,

vector<location> *ploc )

: _name( name ), Query( *ploc ), _present( true )

<
{}

Хотя Query

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

Конструктор базового класса. Если базовых классов несколько, то конструкторы вызываются в порядке их следования в списке базовых классов, а не в порядке появления в списке инициализации. (О множественном наследовании в этой связи мы поговорим в главе 18.)

Конструктор объекта-члена. Если в классе есть несколько таких членов, то конструкторы вызываются в порядке их объявления в классе, а не в порядке появления в списке инициализации (подробнее см. раздел 14.5).

Конструктор производного класса.

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

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

Конструктор базового класса

В нашем базовом классе объявлено два нестатических члена: _solution и _loc:

class Query {

public:

// ...

protected:

set<short> *_solution;

vector<location> _loc;

// ...

};

Конструктор Query по умолчанию должен явно инициализировать только член _solution. Для инициализации _loc автоматически вызывается конструктор класса vector. Вот реализация нашего конструктора:

inline Query::Query(): _solution( 0 ) {}

В Query нам понадобится еще один конструктор, принимающий ссылку на вектор позиций:

inline

Query::

Query( const vector< locaton > &loc )

: _solution( 0 ), _loc( loc )

{}

Он вызывается только из конструктора NameQuery, когда объект этого класса используется для представления указанного в запросе слова. В таком случае передается предварительно подготовленный для него вектор позиций. Остальные три производных класса вычисляют свои векторы позиций в соответствующей функции-члене eval(). (В следующем подразделе мы покажем, как это делается. Реализации функций-членов eval() приведены в разделе 17.5.)

Какой уровень доступа обеспечить для конструкторов? Мы не хотим объявлять их открытыми, так как предполагается, что Query будет существовать в программе только в виде подобъекта в составе объектов производных от него классов. Поэтому мы объявим конструктор не открытым, а защищенным:

class Query {

public:

// ...

protected:

Query();

// ...

};

Ко второму конструктору класса Query

предъявляются еще более жесткие требования: он не только должен конструировать Query в виде подобъекта производного класса, но этот производный класс должен к тому же быть NameQuery. Можно объявить конструктор закрытым, а NameQuery сделать другом класса Query. (В предыдущем разделе мы говорили, что производный класс может получить доступ только к открытым и защищенным членам базового. Поэтому любая попытка вызвать второй конструктор из классов AndQuery, OrQuery или NotQuery приведет к ошибке компиляции.)

class Query {

public:

// ...

protected:

Query();

// ...

private:

explicit Query( const vector<location>& );

};

(Необходимость второго конструктора спорна; вероятно, правильнее заполнить _loc в функции eval()

класса NameQuery. Однако принятый подход в большей степени отвечает нашей цели проиллюстрировать использование конструктора базового класса.)

Конструктор как конвертер

Набор конструкторов класса, принимающих единственный параметр, например, SmallInt(int)

класса SmallInt, определяет множество неявных преобразований в значения типа SmallInt. Так, конструктор SmallInt(int)

преобразует значения типа int в значения типа SmallInt.

extern void calc( SmallInt );

int i;

// необходимо преобразовать i в значение типа SmallInt

// это достигается применением SmallInt(int)

calc( i );

При вызове calc(i)

число i

преобразуется в значение типа SmallInt с помощью конструктора SmallInt(int), вызванного компилятором для создания временного объекта нужного типа. Затем копия этого объекта передается в calc(), как если бы вызов функции был записан в форме:

// Псевдокод на C++

// создается временный объект типа SmallInt

{

SmallInt temp = SmallInt( i );

calc( temp );

}

Фигурные скобки в этом примере обозначают время жизни данного объекта: он уничтожается при выходе из функции.

Типом параметра конструктора может быть тип некоторого класса:

class Number {

public:

// создание значения типа Number из значения типа SmallInt

Number( const SmallInt & );

// ...

};

В таком случае значение типа SmallInt

можно использовать всюду, где допустимо значение типа Number:

extern void func( Number );

SmallInt si(87);

int main()

{ // вызывается Number( const SmallInt & )

func( si );

// ...

}

Если конструктор используется для выполнения неявного преобразования, то должен ли тип его параметра точно соответствовать типу подлежащего преобразованию значения? Например, будет ли в следующем коде вызван SmallInt(int), определенный в классе SmallInt, для приведения dobj к типу SmallInt?

extern void calc( SmallInt );

double dobj;

// вызывается ли SmallInt(int)? Да

// dobj преобразуется приводится от double к int

// стандартным преобразованием

calc( dobj );

Если необходимо, к фактическому аргументу применяется последовательность стандартных преобразований до того, как вызвать конструктор, выполняющий определенное пользователем преобразование. При обращении к функции calc()употребляется стандартное преобразование dobj из типа double в тип int. Затем уже для приведения результата к типу SmallInt вызывается SmallInt(int).

Компилятор неявно использует конструктор с единственным параметром для преобразования его типа в тип класса, к которому принадлежит конструктор. Однако иногда удобнее, чтобы конструктор Number(const SmallInt&) можно было вызывать только для инициализации объекта типа Number значением типа SmallInt, но ни в коем случае не для выполнения неявных преобразований. Чтобы избежать такого употребления конструктора, объявим его явным (explicit):

class Number {

public:

   // никогда не использовать для неявных преобразований

   explicit Number( const SmallInt & );

   // ...

};

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

extern void func( Number );

SmallInt si(87);

int main()

{ // ошибка: не существует неявного преобразования из SmallInt в Number

func( si );

// ...

}

Однако такой конструктор все же можно использовать для преобразования типов, если оно запрошено явно в форме оператора приведения типа:

SmallInt si(87);

int main()

{ // ошибка: не существует неявного преобразования из SmallInt в Number

   func( si );

   func( Number( si ) ); // правильно: приведение типа

   func( static_cast< Number >( si ) ); // правильно: приведение типа

}

Конструктор класса

Среди других функций-членов конструктор выделяется тем, что его имя совпадает с именем класса. Для объявления конструктора по умолчанию мы пишем2:

class Account {

public:

// конструктор по умолчанию ...

Account();

// ...

private:

char *_name;

unsigned int _acct_nmbr;

double _balance;

};

Единственное синтаксическое ограничение, налагаемое на конструктор, состоит в том, что он не должен иметь тип возвращаемого значения, даже void. Поэтому следующие объявления ошибочны:

// ошибки: у конструктора не может быть типа возвращаемого значения

void Account::Account() { ... }

Account* Account::Account( const char *pc ) { ... }

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

Откуда мы знаем, сколько и каких конструкторов определить? Как минимум, необходимо присвоить начальное значение каждому члену, который в этом нуждается. Например, номер счета либо задается явно, либо генерируется автоматически таким образом, чтобы гарантировать его уникальность. Предположим, что он будет создаваться автоматически. Тогда мы должны разрешить инициализировать оставшиеся два члена _name и _balance:

Account( const char *name, double open_balance );

Объект класса Account, инициализируемый конструктором, можно объявить следующим образом:

Account newAcct( "Mikey Matz", 0 );

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

нулем. Один из способов сделать это– предоставить конструктор вида:

Account( const char *name );

Другой способ – включить в конструктор с двумя параметрами значение по умолчанию, равное нулю:

Account( const char *name, double open_balance = 0.0 );

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

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

class Account {

public:

   // конструктор по умолчанию ...

   Account();

   // имена параметров в объявлении указывать необязательно

   Account( const char*, double=0.0 );

   const char* name() { return name; }

   // ...

private:

   // ...

};

Ниже приведены два примера правильного определения объекта класса Account, где конструктору передается один или два аргумента:

int main()

{

   // правильно: в обоих случаях вызывается конструктор

   // с двумя параметрами

   Account acct( "Ethan Stern" );

   Account *pact = new Account( "Michael Lieberman", 5000 );

   if ( strcmp( acct.name(), pact->name() ))

      // ...

}

C++ требует, чтобы конструктор применялся к определенному объекту до его первого использования. Это означает, что как для acct, так и для объекта, на который указывает pact, конструктор будет вызван перед проверкой в инструкции if.

Компилятор перестраивает нашу программу, вставляя вызовы конструкторов. Вот как, по всей вероятности, будет модифицировано определение acct

внутри main():

// псевдокод на C++,

// иллюстрирующий внутреннюю вставку конструктора

int main()

{

   Account acct;

   acct.Account::Account("Ethan Stern", 0.0);

   // ...

}

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

Обработка оператора new

несколько сложнее. Конструктор вызывается только тогда, когда он успешно выделил память. Модификация определения pact в несколько упрощенном виде выглядит так:

// псевдокод на C++,

// иллюстрирующий внутреннюю вставку конструктора при обработке new

int main()

{

   // ...

   Account *pact;

   try {

        pact = _new( sizeof( Account ));

        pact->Acct.Account::Account(

                 "Michael Liebarman", 5000.0);

   }

   catch( std::bad_alloc ) {

          // оператор new закончился неудачей:

          // конструктор не вызывается

   }

   // ...

<

}

Существует три в общем случае эквивалентных формы задания аргументов конструктора:

// в общем случае эти формы эквивалентны

Account acct1( "Anna Press" );

Account acct2 = Account( "Anna Press" );

Account acct3 = "Anna Press";

Форма acct3

может использоваться только при задании единственного аргумента. Если аргументов два или более, мы рекомендуем пользоваться формой acct1, хотя допустима и acct2.

// рекомендуемая форма вызова конструктора

Account acct1( "Anna Press" );

Новички часто допускают ошибку при объявлении объекта, инициализированного конструктором по умолчанию:

// увы! работает не так, как ожидалось

Account newAccount();

Эта инструкция компилируется без ошибок. Однако при попытке использовать объект в таком контексте:

// ошибка компиляции ...

if ( ! newAccount.name() ) ...

компилятор не сможет применить к функции нотацию доступа к членам класса. Определение

// определяет функцию newAccount,

// а не объект класса

Account newAccount();

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

// правильно: определяется объект класса ...

Account newAccount;

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

такой конструктор исключен:

class Account {

public:

   // имена параметров в объявлении указывать необязательно

   Account( const char*, double=0.0 );

   const char* name() { return name; }

   // ...

private:

   // ...

};

Теперь при объявлении каждого объекта Account в конструкторе обязательно надо указать как минимум аргумент типа C-строки, но это скорее всего бессмысленно. Почему? Контейнерные классы (например, vector) требуют, чтобы для класса помещаемых в них элементов был либо задан конструктор по умолчанию, либо вообще никаких конструкторов. Аналогичная ситуация имеет место при выделении динамического массива объектов класса. Так, следующая инструкция вызвала бы ошибку компиляции для новой версии Account:

// ошибка: требуется конструктор по умолчанию для класса Account

Account *pact = new Account[ new_client_cnt ];

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

А если для класса нет разумных значений по умолчанию? Например, класс Account

требует задавать для любого объекта фамилию владельца счета. В таком случае лучше всего установить состояние объекта так, чтобы было видно, что он еще не инициализирован корректными значениями:

// конструктор по умолчанию для класса Account

inline Account::

Account() {

   _name = 0;

   _balance = 0.0;

   _acct_nmbr = 0;

}

Однако в функции-члены класса Account

придется включить проверку целостности объекта перед его использованием.

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

// конструктор по умолчанию класса Account с использованием

// списка инициализации членов

inline Account::

Account()

: _name(0),

_balance( 0.0 ), _acct_nmbr( 0 )

{}

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

inline Account::

Account( const char* name, double opening_bal )

       : _balance( opening_bal )

{

      _name = new char[ strlen(name)+1 ];

      strcpy( _name, name );

      _acct_nmbr = get_unique_acct_nmbr();

}

get_unique_acct_nmbr() – это не являющаяся открытой функция-член, которая возвращает гарантированно не использованный ранее номер счета.

Конструктор нельзя объявлять с ключевыми словами const или volatile (см. раздел 13.3.5), поэтому приведенные записи неверны:

class Account {

public:

   Account() const;     // ошибка

   Account() volatile; // ошибка

   // ...

};

Это не означает, что объекты класса с такими спецификаторами запрещено инициализировать конструктором. Просто к объекту применяется подходящий конструктор, причем без учета спецификаторов в объявлении объекта. Константность объекта класса устанавливается после того, как работа по его инициализации завершена, и пропадает в момент вызова деструктора. Таким образом, объект класса со спецификатором const

считается константным с момента завершения работы конструктора до момента запуска деструктора. То же самое относится и к спецификатору volatile.

Рассмотрим следующий фрагмент программы:

// в каком-то заголовочном файле

extern void print( const Account &acct );

// ...

int main()

{

   // преобразует строку "oops" в объект класса Account

   // с помощью конструктора Account::Account( "oops", 0.0 )

   print( "oops" );

   // ...

}

По умолчанию конструктор с одним параметром (или с несколькими – при условии, что все параметры, кроме первого, имеют значения по умолчанию) играет роль оператора преобразования. В этом фрагменте программы конструктор Account

неявно применяется компилятором для трансформации литеральной строки в объект класса Account при вызове print(), хотя в данной ситуации такое преобразование не нужно.

Непреднамеренные неявные преобразования классов, например трансформация "oops" в объект класса Account, оказались источником трудно обнаруживаемых ошибок. Поэтому в стандарт C++ было добавлено ключевое слово explicit, говорящее компилятору, что такие преобразования не нужны:

class Account {

public:

explicit Account( const char*, double=0.0 );

};

Данный модификатор применим только к конструктору. (Операторы преобразования и слово explicit

обсуждаются в разделе 15.9.2.)

Конструктор по умолчанию

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

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

Account::Account() { ... }

iStack::iStack( int size = 0 ) { ... }

Complex::Complex(double re=0.0, double im=0.0) { ... }

Когда мы пишем:

int main()

{

Account acct;

// ...

}

то компилятор сначала проверяет, определен ли для класса Account конструктор по умолчанию. Возникает одна из следующих ситуаций:

1. Такой конструктор определен. Тогда он применяется к acct.

2. Конструктор определен, но не является открытым. В данном случае определение acct помечается компилятором как ошибка: у функции main() нет прав доступа.

3. Конструктор по умолчанию не определен, но есть один или несколько конструкторов, требующих задания аргументов. Определение acct помечается как ошибка: слишком мало аргументов у конструктора.

4. Нет ни конструктора по умолчанию, ни какого-либо другого. Определение считается корректным, acct не инициализируется, конструктор не вызывается.

Пункты 1 и 3 должны быть уже достаточно понятны (если это не так, перечитайте данную главу) Посмотрим более внимательно на пункты 2 и 4.

Допустим, что все члены класса Account

объявлены открытыми и не объявлено никакого конструктора:

class Account {

public:

char *_name;

unsigned int _acct_nmbr;

double _balance;

};

В таком случае при определении объекта класса Account специальной инициализации не производится. Начальные значения всех трех членов зависят только от контекста, в котором встретилось определение. Например, для статических объектов гарантируется, что все их члены будут обнулены (как и для объектов, не являющихся экземплярами классов):

// статический класс хранения

// вся ассоциированная с объектом память обнуляется

Account global_scope_acct;

static Account file_scope_acct;

Account foo()

{

static Account local_static_acct;

// ...

<
}

Однако объекты, определенные локально или распределенные динамически, в начальный момент будут содержать случайный набор битов, оставшихся в стеке программы:

// локальные и распределенные из хипа объекты не инициализированы

// до момента явной инициализации или присваивания

Account bar()

{

   Account local_acct;

   Account *heap_acct = new Account;

   // ...

}

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

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

Конструктор производного класса

В классе NameQuery

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

class NameQuery : public Query {

public:

explicit NameQuery( const string& );

NameQuery( const string&, const vector<location>* );

// ...

protected:

// ...

};

Конструктор с одним параметром принимает в качестве аргумента строку. Она передается конструктору объекта типа string, который вызывается для инициализации члена _name. Конструктор по умолчанию базового класса Query

вызывается неявно:

inline

NameQuery::

NameQuery( const string &name )

// Query::Query() вызывается неявно

: _name( name )

{}

Конструктор с двумя параметрами также принимает строку в качестве одного из них. Второй его параметр– это указатель на вектор позиций. Он передается закрытому конструктору базового класса Query. (Обратите внимание, что _present нам больше не нужен, и мы исключили его из числа членов NameQuery.)

inline

NameQuery::

NameQuery( const string &name, vector<location> *ploc )

: _name( name ), Query( *ploc )

{}

Конструкторы можно использовать так:

string title( "Alice" );

NameQuery *pname;

// проверим, встречается ли "Alice" в отображении слов

// если да, получить ассоциированный с ним вектор позиций

if ( vector<location> *ploc = retrieve_location( title ))

pname = new NameQuery( title, ploc );

else pname = new NameQuery( title );

В каждом из классов NotQuery, OrQuery и AndQuery определено по одному конструктору, каждый из которых вызывает конструктор базового класса неявно:

inline NotQuery::

NotQuery( Query *op = 0 ) : _op( op ) {}

inline OrQuery::

OrQuery( Query *lop = 0, Query *rop = 0 )

: _lop( lop ), _rop( rop )

{}

inline AndQuery::

AndQuery( Query *lop = 0, Query *rop = 0 )

: _lop( lop ), _rop( rop )

{}

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

Конструкторы и функциональные try-блоки

Можно объявить функцию так, что все ее тело будет заключено в try-блок. Такие try-блоки называются функциональными. (Мы упоминали их в разделе 11.2.) Например:

int main() {

try {

// тело функции main()

}

catch ( pushOnFull ) {

// ...

}

catch ( popOnEmpty ) {

// ...

}

Функциональный try-блок ассоциирует группу catch-обработчиков с телом функции. Если инструкция внутри тела возбуждает исключение, то поиск его обработчика ведется среди тех, что следуют за телом функции.

Функциональный try-блок необходим для конструкторов класса. Почему? Определение конструктора имеет следующий вид:

имя_класса( список_параметров )

// список инициализации членов:

: член1(выражение1 ) , // инициализация член1

член2(выражение2 ) , // инициализация член2

// тело функции:

{ /* ... */ }

выражение1 и выражение2

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

Рассмотрим еще раз класс Account, описанный в главе 14. Его конструктор можно переопределить так:

inline Account::

Account( const char* name, double opening_bal )

: _balance( opening_bal - ServiceCharge() )

{

_name = new char[ strlen(name) + 1 ];

strcpy( _name, name );

_acct_nmbr = get_unique_acct_nmbr();

}

Функция ServiceCharge(), вызываемая для инициализации члена _balance, может возбуждать исключение. Как нужно реализовать конструктор, если мы хотим обрабатывать все исключения, возбуждаемые функциями, которые вызываются при конструировании объекта типа Account?

Помещать try-блок в тело функции нельзя:

inline Account::

Account( const char* name, double opening_bal )

: _balance( opening_bal - ServiceCharge() )

{

try {

_name = new char[ strlen(name) + 1 ];

strcpy( _name, name );

_acct_nmbr = get_unique_acct_nmbr();

}

catch (...) {

// специальная обработка

// не перехватывает исключения,

// возбужденные в списке инициализации членов

}

Поскольку try- блок не охватывает список инициализации членов, то catch-обработчик, находящийся в конце конструктора, не рассматривается при поиске кандидатов, которые способны перехватить исключение, возбужденное в функции ServiceCharge().

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

inline Account::

Account( const char* name, double opening_bal )

try

       : _balance( opening_bal - ServiceCharge() )

{

   _name = new char[ strlen(name) + 1 ];

   strcpy( _name, name );

   _acct_nmbr = get_unique_acct_nmbr();

}

catch (...) {

   // теперь специальная обработка

   // перехватывает исключения,

   // возбужденные в ServiceCharge()

}

Обратите внимание, что ключевое слово try

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

Контейнеры multimap и multiset

Контейнеры map и set не допускают повторяющихся значений ключей, а multimap (мультиотображение) и multiset

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

#include <map>

multimap< key_type, value_type > multimapName;

// ключ - string, значение - list< string >

multimap< string, list< string > > synonyms;

#include <set>

multiset< type > multisetName;

Для прохода по мультиотображению или мультимножеству можно воспользоваться комбинацией итератора, который возвращает find() (он указывает на первый найденный элемент), и значения, которое возвращает count(). (Это работает, поскольку в данных контейнерах элементы с одинаковыми ключами обязательно являются соседними). Например:

#include <map>

#include <string>

void code_fragment()

{

multimap< string, string > authors;

string search_item( "Alain de Botton" );

// ...

int number = authors.count( search_item );

mu1timap< string,string >::iterator iter;

iter = authors.find( search_item );

for ( int cnt = 0; cnt < number; ++cnt, ++-iter )

do_something( *iter );

// ...

}

Более элегантный способ перебрать все значения с одинаковыми ключами использует специальную функцию-член equal_range(), которая возвращает пару итераторов. Один из них указывает на первое найденное значение, а второй – на следующее за последним найденным. Если последний из найденных элементов является последним в контейнере, второй итератор содержит величину, равную end():

#include <map>

#include <string>

#include <utility>

void code_fragment()

{

multimap< string, string > authors;

// ...

string search_item( "Haruki Murakami" );

while ( cin && cin >> search_item )

switch ( authors.count( search_item ))

{

// не найдено

case 0:

break;

// найден 1, обычный find()

case 1: {

multimap< string, string >: iterator iter;

iter = authors.find( search_item );

// обработка элемента ...

break;

}

// найдено несколько ...

default:

{

typedef multimap<string,string>::iterator iterator;

pair< iterator, iterator > pos;

// pos.first - адрес 1-го найденного

// pos.second - адрес 1-го отличного

// от найденного

pos = authors.equa1_range( search_item );

for (; pos.first != pos.second; pos.first++ )

// обработка элемента ...

}

<
}

Вставка и удаление элементов в multimap и multiset ничем не отличаются от аналогичных операций с контейнерами map и set. Функция equal_range() доставляет итераторную пару, задающую диапазон удаляемых элементов:

#include <multimap>

#include <string>

typedef multimap< string, string >::iterator iterator;

pair< iterator, iterator > pos;

string search_item( "Kazuo Ishiguro" );

// authors - multimap<string, string>

// эквивалентно

// authors.erase( search_item );

pos = authors.equa1_range( search_item );

authors.erase( pos.first, pos.second );

При каждом вызове функции-члена insert()

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

typedef multimap<string,string>::value_type valType;

multimap<string,string> authors;

// первый элемент с ключом Barth

authors.insert( valType (

    string( "Barth, John" ),

    string( "Sot-Weed Factor" )));

// второй элемент с ключом Barth

authors.insert( va1Type(

    string( "Barth, John" ),

string( "Lost in the Funhouse" )));

Контейнер multimap не поддерживает операцию взятия индекса. Поэтому следующее выражение ошибочно:

authors[ "Barth, John" ]; // ошибка: multimap

Упражнение 6.28

Перепишите программу текстового поиска из раздела 6.14 с использованием multimap для хранения позиций слов. Каковы производительность и дизайн в обоих случаях? Какое решение вам больше нравится? Почему?

Конвертеры

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

Имя, находящееся за ключевым словом, не обязательно должно быть именем одного из встроенных типов. В показанном ниже классе Token определено несколько конвертеров. В одном из них для задания имени типа используется typedef tName, а в другом – тип класса SmallInt.

#include "SmallInt.h"

typedef char *tName;

class Token {

public:

Token( char *, int );

operator SmallInt() { return val; }

operator tName() { return name; }

operator int() { return val; }

// другие открытые члены

private:

SmallInt val;

char *name;

};

Обратите внимание, что определения конвертеров в типы SmallInt и int одинаковы. Конвертер Token::operator int()

возвращает значение члена val. Поскольку val

имеет тип SmallInt, то неявно применяется SmallInt::operator int() для преобразования val в тип int. Сам Token::operator int() неявно употребляется компилятором для преобразования объекта типа Token в значение типа int. Например, этот конвертер используется для неявного приведения фактических аргументов t1 и t2

типа Token к типу int

формального параметра функции print():

#include "Token.h"

void print( int i )

{

cout << "print( int ) : " << i << endl;

}

Token t1( "integer constant", 127 );

Token t2( "friend", 255 );

int main()

{

print( t1 ); // t1.operator int()

print( t2 ); // t2.operator int()

return 0;

}

После компиляции и запуска программа выведет такие строки:

print( int ) : 127

print( int ) : 255

Общий вид конвертера следующий:

operator type();

где type

может быть встроенным типом, типом класса или именем typedef. Конвертеры, в которых type – тип массива или функции, не допускаются. Конвертер должен быть функцией-членом. В его объявлении не должны задаваться ни тип возвращаемого значения, ни список параметров:

operator int( SmallInt & ); // ошибка: не член

class SmallInt {

public:

   int operator int();       // ошибка: задан тип возвращаемого значения

   operator int( int = 0 ); // ошибка: задан список параметров

   // ...

};

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

#include "Token.h"

Token tok( "function", 78 );

// функциональная нотация: вызывается Token::operator SmallInt()

SmallInt tokVal = SmallInt( tok );

// static_cast: вызывается Token::operator tName()

char *tokName = static_cast< char * >( tok );

У конвертера Token::operator tName()

может быть нежелательный побочный эффект. Попытка прямого обращения к закрытому члену Token::name

помечается компилятором как ошибка:

char *tokName = tok.name; // ошибка: Token::name - закрытый член

Однако наш конвертер, разрешая пользователям непосредственно изменять Token::name, делает как раз то, от чего мы хотели защититься. Скорее всего, это не годится. Вот, например, как могла бы произойти такая модификация:

#include "Token.h"

Token tok( "function", 78 );

char *tokName = tok; // правильно: неявное преобразование

*tokname = 'P'; // но теперь в члене name находится Punction!

Мы намереваемся разрешить доступ к преобразованному объекту класса Token только для чтения. Следовательно, конвертер должен возвращать тип const char*:

typedef const char *cchar;

class Token {

public:

operator cchar() { return name; }

// ...

};

// ошибка: преобразование char* в const char* не допускается

char *pn = tok;

const char *pn2 = tok; // правильно

Другое решение – заменить в определении Token тип char* на тип string из стандартной библиотеки C++:

class Token {

public:

   Token( string, int );

   operator SmallInt() { return val; }

   operator string()   { return name; }

   operator int()      { return val; }

   // другие открытые члены

private:

   SmallInt val;

   string name;

<

};

Семантика конвертера Token::operator string() состоит в возврате копии значения ( а не указателя на значение) строки, представляющей имя лексемы. Это предотвращает случайную модификацию закрытого члена name класса Token.

Должен ли целевой тип точно соответствовать типу конвертера? Например, будет ли в следующем коде вызван конвертер int(), определенный в классе Token?

extern void calc( double );

Token tok( "constant", 44 );

// Вызывается ли оператор int()? Да

// применяется стандартное преобразование int --> double

calc( tok );

Если целевой тип (в данном случае double) не точно соответствует типу конвертера (в нашем случае int), то конвертер все равно будет вызван при условии, что существует последовательность стандартных преобразований, приводящая к целевому типу из типа конвертера. (Эти последовательности описаны в разделе 9.3.) При обращении к функции calc()

вызывается Token::operator int() для преобразования tok из типа Token в тип int. Затем для приведения результата от типа int к типу double

применяется стандартное преобразование.

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

extern void calc( int );

Token tok( "pointer", 37 );

// если Token::operator int() не определен,

// то этот вызов приводит к ошибке компиляции

calc( tok );

Если конвертер Token::operator int() не определен, то приведение tok к типу int

потребовало бы вызова двух определенных пользователем конвертеров. Сначала фактический аргумент tok

надо было бы преобразовать из типа Token в тип SmallInt с помощью конвертера

Token::operator SmallInt()

а затем результат привести к типу int – тоже с помощью пользовательского конвертера

Token::operator int()

Вызов calc(tok)

помечается компилятором как ошибка, так как не существует неявного преобразования из типа Token в тип int.

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

class Date {

public:

   // попробуйте догадаться, какой именно член возвращается!

   operator int();

private:

   int month, day, year;

};

Какое значение должен вернуть конвертер int() класса Date? Сколь бы основательными ни были причины для того или иного решения, читатель останется в недоумении относительно того, как пользоваться объектами класса Date, поскольку между ними и целыми числами нет явного логического соответствия. В таких случаях лучше вообще не

определять конвертер.

Копирующий конструктор

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

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

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

inline Account::

Account( const Account &rhs )

: _balance( rhs._balance )

{

_name = new char[ strlen(rhs._name) + 1 ];

strcpy( _name, rhs._name );

// копировать rhs._acct_nmbr нельзя

_acct_nmbr = get_unique_acct_nmbr();

}

Когда мы пишем:

Account acct2( acct1 );

компилятор определяет, объявлен ли явный копирующий конструктор для класса Account. Если он объявлен и доступен, то он и вызывается; а если недоступен, то определение acct2

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

Упражнение 14.1

Какие из следующих утверждений ложны? Почему?

1. У класса должен быть хотя бы один конструктор.

2. Конструктор по умолчанию – это конструктор с пустым списком параметров.

3. Если разумных начальных значений у членов класса нет, то не следует предоставлять конструктор по умолчанию.

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

Упражнение 14.2

Предложите один или несколько конструкторов для данного множества членов. Объясните свой выбор:

class NoName {

public:

   // здесь должны быть конструкторы

   // ...

protected:

   char   *pstring;

   int    ival;

   double dval;

};

Упражнение 14.3

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

·                  Книга

·                  Дата

·                  Служащий

·                  Транспортное средство

·                  Объект

·                  Дерево

Упражнение 14.4

Пользуясь приведенным определением класса:

class Account {

public:

   Account();

   explicit Account( const char*, double=0.0 );

   // ...

};

объясните, что происходит в результате следующих определений:

(a) Account acct;

(b) Account acct2 = acct;

(c) Account acct3 = "Rena Stern";

(d) Account acct4( "Anna Engel", 400.00 );

(e) Account acct5 = Account( acct3 );

Упражнение 14.5

Параметр копирующего конструктора может и не быть константным, но обязан быть ссылкой. Почему ошибочна такая инструкция:

Account::Account( const Account rhs );

Краткий обзор

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

1. По очереди исследовать каждый элемент.

2. Если элемент равен искомому значению, то вернуть его позицию в коллекции.

3. В противном случае анализировать следующий элемент Повторять шаг 2, пока значение не будет найдено либо пока не будет просмотрена вся коллекция.

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

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

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

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

· некоторый обобщенный тип для представления позиции элемента внутри контейнера и специального признака на случай, если элемент не найден. Обычно мы возвращаем индекс элемента либо указатель на него. В ситуации, когда поиск неудачен, возвращается –1 вместо индекса или 0 вместо указателя.

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

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

Имеется по две версии каждого обобщенного алгоритма: в одной для сравнения применяется оператор равенства, а в другой – объект-функция или указатель на функцию, реализующую сравнение. (Объекты-функции рассматриваются в разделе 12.3.) Вот, например, реализация обобщенного алгоритма find(), в котором используется оператор сравнения для типов хранимых в контейнере элементов:

template < class ForwardIterator, class Type >

ForwardIterator

find( ForwardIterator first, ForwardIterator last, Type value )

{

   for ( ; first != last; ++first )

             if ( value == *first )

          return first;

   return last;

}

ForwardIterator

(однонаправленный итератор) – это один из пяти категорий итераторов, предопределенных в стандартной библиотеке. Он поддерживает чтение и запись адресуемого элемента. (Все пять категорий рассматриваются в разделе 12.4.)

Алгоритмы достигают независимости от типов за счет того, что никогда не обращаются к элементам контейнера непосредственно; доступ и обход элементов осуществляются только с помощью итераторов. Неизвестны ни фактический тип контейнера, ни даже то, является ли он контейнером или встроенным массивом. Для работы со встроенным типом массива обобщенному алгоритму можно передать не только обычные указатели, но и итераторы. Например, алгоритм find() для встроенного массива элементов типа int можно использовать так:

#include <algoritm>

#include <iostream>

int main()

{

   int search_value;

   int ia[ 6 ] = { 27, 210, 12, 47, 109, 83 };

   cout << "enter search value: ";

   cin >> search_value;

   int *presult = find( &ia[0], &ia[6], search_value );

   cout << "The value " << search_value

        << ( presult == &ia[6]

            ? " is not present" : " is present" )

   << endl;

}

Если возвращенный указатель равен адресу &ia[6] (который расположен за последним элементом массива), то поиск оказался безрезультатным, в противном случае значение найдено.

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

int *presult = find( &ia[0], &ia[6], search_value );

или

int *presult = find( ia, ia+6, search_value );

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

просматриваются только второй и третий элементы (напомним, что элементы массива нумеруются с нуля):

// искать только среди элементов ia[1] и ia[2]

int *presult = find( &ia[1], &ia[3], search_value );

А вот пример использования контейнера типа vector с алгоритмом find():

#include <algorithm>

#include <vector>

#include <iostream>

int main()

{

   int search_value;

   int ia[ 6 ] = { 27, 210, 12, 47, 109, 83 };

   vector<int> vec( ia, ia+6 );

   cout << "enter search value: ";

   cin >> search_value;

   vector<int>::iterator presult;

   presult = find( vec.begin(), vec.end(), search_value );

   cout << "The value " << search_value

        << ( presult == vec.end()

            ? " is not present" : " is present" )

        << endl;

}

find() можно применить и к списку:

#include <algorithm>

#include <list>

#include <iostream>

int main()

{

   int search_value;

   int ia[ 6 ] = { 27, 210, 12, 47, 109, 83 };

   list<int> ilist( ia, ia+6 );

   cout << "enter search value: ";

   cin >> search_value;

   list<int>::iterator presult;

   presult = find( ilist.begin(), ilist.end(), search_value );

   cout << "The value " << search_value

        << ( presult == ilist.end()

            ? " is not present" : " is present" )

   << endl;

}

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

Упражнение 12.1

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

Краткий обзор С++

Эту главу мы начнем с рассмотрения встроенного в язык С++ типа данных “массив”. Массив – это набор данных одного типа, например массив целых чисел или массив строк. Мы рассмотрим недостатки, присущие встроенному массиву, и напишем для его представления свой класс Array, где попытаемся избавиться от этих недостатков. Затем мы построим целую иерархию подклассов, основываясь на нашем базовом классе Array. В конце концов мы сравним наш класс Array с классом vector из стандартной библиотеки С++, реализующим аналогичную функциональность. В процессе создания этих классов мы коснемся таких свойств С++, как шаблоны, пространства имен и обработка ошибок.

Литералы

В С++ имеется набор встроенных типов данных для представления целых и вещественных чисел, символов, а также тип данных “символьный массив”, который служит для хранения символьных строк. Тип char

служит для хранения отдельных символов и небольших целых чисел. Он занимает один машинный байт. Типы short, int и long

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

занимает половину машинного слова, int– одно слово, long – одно или два слова. В 32-битных системах int и long, как правило, одного размера.

Типы float, double и long double предназначены для чисел с плавающей точкой и различаются точностью представления (количеством значащих разрядов) и диапазоном. Обычно float

(одинарная точность) занимает одно машинное слово, double

(двойная точность) – два, а long double (расширенная точность) – три.

char, short, int и long вместе составляют целые типы, которые, в свою очередь, могут быть знаковыми (signed) и беззнаковыми (unsigned). В знаковых типах самый левый бит служит для хранения знака (0 – плюс, 1 – минус), а оставшиеся биты содержат значение. В беззнаковых типах все биты используются для значения. 8-битовый тип signed char

может представлять значения от -128 до 127, а unsigned char – от 0 до 255.

Когда в программе встречается некоторое число, например 1, то это число называется литералом, или литеральной константой. Константой, потому что мы не можем изменить его значение, и литералом, потому что его значение фигурирует в тексте программы. Литерал является неадресуемой величиной: хотя реально он, конечно, хранится в памяти машины, нет никакого способа узнать его адрес. Каждый литерал имеет определенный тип. Так, 0 имеет тип int, 3.14159 – тип double.

Литералы целых типов можно записать в десятичном, восьмеричном и шестнадцатеричном виде. Вот как выглядит число 20, представленное десятичным, восьмеричным и шестнадцатеричным литералами:

20     // десятичный

024    // восьмеричный

0х14   // шестнадцатеричный

Если литерал начинается с 0, он трактуется как восьмеричный, если с 0х или 0Х, то как шестнадцатеричный. Привычная запись рассматривается как десятичное число.

По умолчанию все целые литералы имеют тип signed int. Можно явно определить целый литерал как имеющий тип long, приписав в конце числа букву L (используется как прописная L, так и строчная l, однако для удобства чтения не следует употреблять строчную: ее легко перепутать с 1).

Буква U

(или u) в конце определяет литерал как unsigned int, а две буквы – UL или LU – как тип unsigned long. Например:

128u 1024UL    1L    8Lu

Литералы, представляющие действительные числа, могут быть записаны как с десятичной точкой, так и в научной (экспоненциальной) нотации. По умолчанию они имеют тип double. Для явного указания типа float

нужно использовать суффикс F или f, а для long double - L или l, но только в случае записи с десятичной точкой. Например:

3.14159F 0/1f    12.345L 0.0

3el      1.0E-3E 2.       1.0L

Слова true и false

являются литералами типа bool.

Представимые литеральные символьные константы записываются как символы в одинарных кавычках. Например:

'a'    '2'    ','    ' ' (пробел)

Специальные символы (табуляция, возврат каретки) записываются как escape-последовательности . Определены следующие такие последовательности (они начинаются с символа обратной косой черты):

новая строка             \n

горизонтальная табуляция \t

забой                    \b

вертикальная табуляция   \v

возврат каретки          \r

прогон листа             \f

звонок                   \a

обратная косая черта     \\

вопрос                   \?

одиночная кавычка        \'

двойная кавычка          \"

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

\7 (звонок)   \14 (новая строка)

\0 (null)     \062 ('2')

Символьный литерал может иметь префикс L

(например, L'a'), что означает специальный тип wchar_t – двухбайтовый символьный тип, который применяется для хранения символов национальных алфавитов, если они не могут быть представлены обычным типом char, как, например, китайские или японские буквы.

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

"" (пустая строка)

"a"

"\nCC\toptions\tfile.[cC]\n"

"a multi-line \

string literal signals its \

continuation with a backslash"

Фактически строковый литерал представляет собой массив символьных констант, где по соглашению языков С и С++ последним элементом всегда является специальный символ с кодом 0 (\0).

Литерал 'A'

задает единственный символ А, а строковый литерал "А" – массив из двух элементов: 'А' и \0

(пустого символа).

Раз существует тип wchar_t, существуют и литералы этого типа, обозначаемые, как и в случае с отдельными символами, префиксом L:

L"a wide string literal"

Строковый литерал типа wchar_t – это массив символов того же типа, завершенный нулем.

Если в тесте программы идут подряд два или несколько строковых литералов (типа char или wchar_t), компилятор соединяет их в одну строку. Например, следующий текст

"two" "some"

породит массив из восьми символов – twosome и завершающий нулевой символ. Результат конкатенации строк разного типа не определен. Если написать:

// this is not a good idea

"two" L"some"

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

Упражнение 3.1

Объясните разницу в определениях следующих литералов:

(a) 'a', L'a', "a", L"a"

(b) 10, 10u, 10L, 10uL, 012, 0*C

(a) "Who goes with F\144rgus?\014"

(b) 3.14e1L

(c) "two" L"some"

(d) 1024f

(e) 3.14UL

(f) "multiple line

comment"

Логические объекты-функции

Логические объекты-функции поддерживают операции “логическое И” (возвращает true, если оба операнда равны true, – применяет оператор &&, аcсоциированный с типом Type), “логическое ИЛИ” (возвращает true, если хотя бы один из операндов равен true, – применяет оператор ||, аcсоциированный с типом Type) и “логическое НЕ” (возвращает true, если операнд равен false, – применяет оператор !, аcсоциированный с типом Type)

· Логическое И: logical_and<Type>

logical_and<int> intAnd;

ires = intLess( ival1, ival2 );

dres = BinaryFunc( logical_and<double>(), dval1, dval2 );

· Логическое ИЛИ: logical_or<Type>

logical_or<int> intSub;

ires = intSub( ival1, ival2 );

dres = BinaryFunc( logical_or<double>(), dval1, dval2 );

· Логическое НЕ: logical_not<Type>

logical_not<Int> IntNot;

ires = IntNot( Ival1, Ival2 );

dres = UnaryFunc( logical_or<double>(), dval1 );

Локальная область видимости

Локальная область видимости – это часть исходного текста программы, содержащаяся в определении функции (или блоке внутри тела функции). Все функции имеют свои локальные области видимости. Каждая составная инструкция (или блок) внутри функции также представляет собой отдельную локальную область. Такие области могут быть вложенными. Например, следующее определение функции содержит два их уровня (функция выполняет двоичный поиск в отсортированном векторе целых чисел):

const int notFound = -1; // глобальная область видимости

int binSearch( const vector<int> &vec, int val )

{ // локальная область видимости: уровень #1

int low = 0;

int high = vec.size() - 1;

while ( low <= high )

{ // локальная область видимости: уровень #2

int mid = ( low + high ) / 2;

if ( val < vec[ mid ] )

high = mid - 1;

else low = mid + 1;

}

return notFound; // локальная область видимости: уровень #1

}

Первая локальная область видимости – тело функции binSearch(). В ней объявлены параметры функции vec и val, а также переменные low и high. Цикл while

внутри функции задает вложенную локальную область, в которой определена одна переменная mid. Параметры vec и val и переменные low и high

видны во вложенной области. Глобальная область видимости включает в себя обе локальных. В ней определена одна целая константа notFound.

Имена параметров функции vec и val

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

int binSearch( const vector<int> &vec, int val )

{ // локальная область видимости: уровень #1

int val; // ошибка: неверное переопределение val

// ...

Имена параметров употребляются как внутри тела функции binSearch(), так и внутри вложенной области видимости цикла while. Параметры vec и val

недоступны вне тела функции binSearch().

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

Из- за порядка просмотра областей видимости в процессе разрешения имен объявление из внешней области может быть скрыто

объявлением того же имени во вложенной области. Если бы в предыдущем примере переменная low

была объявлена в глобальной области видимости перед определением функции binSearch(), то использование low в локальной области видимости цикла while все равно относилось бы к локальному объявлению, скрывающему глобальное:

int low;

int binSearch( const vector<int> &vec, int val )

{

    // локальное объявление low

    // скрывает глобальное объявление

    int low = 0;

    // ...

    // low - локальная переменная

    while ( low <= high )

    {//...

    }

    // ...

}

Для некоторых инструкций языка C++ разрешено объявлять переменные внутри управляющей части. Например, в цикле for переменную можно определить внутри инструкции инициализации:

for ( int index = 0; index < vecSize; ++index )

{

    // переменная index видна только здесь

    if ( vec[ index ] == someValue )

        break;

}

// ошибка: переменная index не видна

if ( index != vecSize ) // элемент найден

Подобные переменные видны только в локальной области самого цикла for и вложенных в него (это верно для стандарта С++, в предыдущих версиях языка поведение было иным). Компилятор рассматривает это объявление так же, как если бы оно было записано в виде:

// представление компилятора

{ // невидимый блок

    int index = 0;

    for ( ; index < vecSize; ++index )

    {

      // ...

    }

}

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

int index = 0;

for ( ; index < vecSize; ++index )

{

// ...

}

// правильно: переменная index видна

if ( index != vecSize ) // элемент найден

Поскольку переменная, объявленная в инструкции инициализации цикла for, является локальной для цикла, то же самое имя допустимо использовать аналогичным образом и в других циклах, расположенных в данной локальной области видимости:

void fooBar( int *ia, int sz )

{

     for (int i=0; i<sz; ++i) ... // правильно

     for (int i=0; i<sz; ++i) ... // правильно, другое i

     for (int i=0; i<sz; ++i) ... // правильно, другое i

}

Аналогично переменная может быть объявлена внутри условия инструкций if и switch, а также внутри условия циклов while и for. Например:

if ( int *pi = getValue() )

{

    // pi != 0 -- *pi можно использовать здесь

    int result = calc(*pi);

    // ...

}

else

{

    // здесь pi тоже видна

    // pi == 0

    cout << "ошибка: getValue() завершилась неудачно" << endl;

}

Переменные, определенные в условии инструкции if, как переменная pi, видны только внутри if и соответствующей части else, а также во вложенных областях. Значением условия является значение этой переменной, которое она получает в результате инициализации. Если pi

равна 0

(нулевой указатель), условие ложно и выполняется ветвь else. Если pi

инициализируется любым другим значением, условие истинно и выполняется ветвь if. (Инструкции if, switch, for и while

рассматривались в главе 5.)

Упражнение 8.1

Найдите различные области видимости в следующем примере. Какие объявления ошибочны и почему?

int ix = 1024;

int ix() ;

void func( int ix, int iy ) {

    int ix = 255;

    if (int ix=0) {

       int ix = 79;

       {

           int ix = 89;

       }

    }

    else {

        int ix = 99;

    }

}

Упражнение 8.2

К каким объявлениям относятся различные использования переменных ix и iy в следующем примере:

int ix = 1024;

void func( int ix, int iy ) {

    ix = 100;

    for( int iy = 0; iy < 400; iy += 100 ) {

        iy += 100;

        ix = 300;

    }

    iy = 400;

}

Локальные классы A

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

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

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

void foo( int val )

{

class Bar {

public:

int barVal;

class nested; // объявление вложенного класса обязательно

};

// определение вложенного класса

class Bar::nexted {

// ...

};

}

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

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

int a, val;

void foo( int val )

{

   static int si;

   enum Loc { a = 1024, b };

   class Bar {

   public:

      Loc locVal;   // правильно

      int barVal;

      void fooBar ( Loc l = a ) { // правильно: Loc::a

         barVal = val;       // ошибка: локальный объект

         barVal = ::val;     // правильно: глобальный объект

         barVal = si;        // правильно: статический локальный объект

         locVal = b;         // правильно: элемент перечисления

      }

   };

   // ...

}

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

Как всегда, если первое найденное объявление таково, что употребление имени оказывается некорректным, поиск других объявлений не производится. Несмотря на то что использование val в fooBar()

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

Локальные объекты

Объявление переменной в локальной области видимости вводит локальный объект. Существует три вида таких объектов: автоматические, регистровые и статические, различающиеся временем жизни и характеристиками занимаемой памяти. Автоматический объект существует с момента активизации функции, в которой он определен, до выхода из нее. Регистровый объект – это автоматический объект, для которого поддерживается быстрое считывание и запись его значения. Локальный статический объект располагается в области памяти, существующей на протяжении всего времени выполнения программы. В этом разделе мы рассмотрим свойства всех этих объектов.

Массивы и векторы объектов

Массив объектов класса определяется точно так же, как массив элементов встроенного типа. Например:

Account table[ 16 ];

определяет массив из 16 объектов Account. Каждый элемент по очереди инициализируется конструктором по умолчанию. Можно и явно передать конструкторам аргументы внутри заключенного в фигурные скобки списка инициализации массива. Строка:

Account pooh_pals[] = { "Piglet", "Eeyore", "Tigger" };

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

Account( "Piglet", 0.0 ); // первый элемент (Пятачок)

Account( "Eeyore", 0.0 ); // второй элемент (Иа-Иа)

Account( "Tigger", 0.0 ); // третий элемент (Тигра)

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

Account pooh_pals[] = {

Account( "Piglet", 1000.0 ),

Account( "Eeyore", 1000.0 ),

Account( "Tigger", 1000.0 )

};

Чтобы включить в список инициализации массива конструктор по умолчанию, мы употребляем явный вызов с пустым списком параметров:

Account pooh_pals[] = {

Account( "Woozle", 10.0 ), // Бука

Account( "Heffalump", 10.0 ), // Слонопотам

Account();

};

Эквивалентный массив из трех элементов можно объявить и так:

Account pooh_pals[3] = {

Account( "Woozle", 10.0 ),

Account( "Heffalump", 10.0 )

};

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

Доступ к отдельным элементам массива объектов производится с помощью оператора взятия индекса, как и для массива элементов любого из встроенных типов. Например:

pooh_pals[0];

обращается к Piglet, а

pooh_pals[1];

к Eeyore и т.д. Для доступа к членам объекта, находящегося в некотором элементе массива, мы сочетаем операторы взятия индекса и доступа к членам:

pooh_pals[1]._name != pooh_pals[2]._name;

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

Объявление

Account *pact = new Account[ 10 ];

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

Чтобы уничтожить массив, адресованный указателем pact, необходимо применить оператор delete. Однако написать

// увы! это не совсем правильно

delete pact;

недостаточно, так как pact при этом не идентифицируется как массив объектов. В результате деструктор класса Account

применяется лишь к первому элементу массива. Чтобы применить его к каждому элементу, мы должны включить пустую пару скобок между оператором delete и адресом удаляемого объекта:

// правильно:

// показывает, что pact адресует массив

delete [] pact;

Пустая пара скобок говорит о том, что pact

адресует именно массив. Компилятор определяет, сколько в нем элементов, и применяет деструктор к каждому из них.

Массивы указателей на функции

Можно объявить массив указателей на функции. Например:

int (*testCases[10])();

testCases – это массив из десяти элементов, каждый из которых является указателем на функцию, возвращающую значение типа int и не имеющую параметров.

Подобные объявления трудно читать, поскольку не сразу видно, с какой частью ассоциируется тип функции.

В этом случае помогает использование имен, определенных с помощью директивы typedef:

// typedef делает объявление более понятным

typedef int (*PFV)(); // typedef для указателя на функцию

PFV testCases[10];

Данное объявление эквивалентно предыдущему.

Вызов функций, адресуемых элементами массива testCases, выглядит следующим образом:

const int size = 10;

PFV testCases[size];

int testResults[size];

void runtests() {

for ( int i = 0; i < size; ++i )

// вызов через элемент массива

testResults[ i ] = testCases[ i ]();

}

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

int lexicoCompare( const string &, const string & );

int sizeCompare( const string &, const string & );

typedef int ( *PFI2S )( const string &, const string & );

PFI2S compareFuncs[2] =

{

lexicoCompare,

sizeCompare

};

Можно объявить и указатель на compareFuncs, его типом будет “указатель на массив указателей на функции”:

PFI2S (*pfCompare)[2] = compareFuncs;

Это объявление раскладывается на составные части следующим образом:

(*pfCompare)

Оператор разыменования говорит, что pfCompare является указателем. [2]

сообщает о количестве элементов массива:

(*pfCompare) [2]

PFI2S – имя, определенное с помощью директивы typedef, называет тип элементов. Это “указатель на функцию, возвращающую int и имеющую два параметра типа const string &”. Тип элемента массива тот же, что и выражения &lexicoCompare.

Такой тип имеет и первый элемент массива compareFuncs, который может быть получен с помощью любого из выражений:

compareFunc[ 0 ];

(*pfCompare)[ 0 ];

Чтобы вызвать функцию lexicoCompare

через pfCompare, нужно написать одну из следующих инструкций:

// эквивалентные вызовы

pfCompare [ 0 ]( string1, string2 ); // сокращенная форма

((*pfCompare)[ 0 ])( string1, string2 ); // явная форма

Многомерные массивы

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

int ia[ 4 ][ 3 ];

Первая величина (4) задает количество строк, вторая (3)– количество столбцов. Объект ia

определен как массив из четырех строк по три элемента в каждой. Многомерные массивы тоже могут быть инициализированы:

int ia[ 4 ][ 3 ] = {

{ 0, 1, 2 },

{ 3, 4, 5 },

{ 6, 7, 8 },

{ 9, 10, 11 }

};

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

int ia[4][3] = { 0,1,2,3,4,5,6,7,8,9,10,11 };

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

int ia[ 4 ][ 3 ] = { {0}, {3}, {6}, {9} };

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

int ia[ 4 ][ 3 ] = { 0, 3, 6, 9 };

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

int main()

{

const int rowSize = 4;

const int colSize = 3;

int ia[ rowSize ][ colSize ];

for ( int = 0; i < rowSize; ++i )

for ( int j = 0; j < colSize; ++j )

ia[ i ][ j ] = i + j j;

}

Конструкция

ia[ 1, 2 ]

является допустимой с точки зрения синтаксиса С++, однако означает совсем не то, чего ждет неопытный программист. Это отнюдь не объявление двумерного массива 1 на 2. Агрегат в квадратных скобках – это список выражений через запятую, результатом которого будет последнее значение 2 (см. оператор “запятая” в разделе 4.2). Поэтому объявление ia[1,2] эквивалентно ia[2]. Это еще одна возможность допустить ошибку.

Многоточие

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

void foo( parm_list, ... );

void foo( ... );

Первый формат предоставляет объявления для части параметров. В этом случае проверка типов для объявленных параметров производится, а для оставшихся фактических аргументов – нет. Запятая после объявления известных параметров необязательна.

Примером вынужденного использования многоточия служит функция printf()

стандартной библиотеки С. Ее первый параметр является C-строкой:

int printf( const char* ... );

Это гарантирует, что при любом вызове printf() ей будет передан первый аргумент типа const char*. Содержание такой строки, называемой форматной, определяет, необходимы ли дополнительные аргументы при вызове. При наличии в строке формата метасимволов, начинающихся с символа %, функция ждет присутствия этих аргументов. Например, вызов

printf( "hello, world\n" );

имеет один строковый аргумент. Но

printf( "hello, %s\n", userName );

имеет два аргумента. Символ %

говорит о наличии второго аргумента, а буква s, следующая за ним, определяет его тип – в данном случае символьную строку.

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

Отметим, что следующие объявления неэквивалентны:

void f();

void f( ... );

В первом случае f()

объявлена как функция без параметров, во втором – как имеющая ноль или более параметров. Вызовы

f( someValue );

f( cnt, a, b, с );

корректны только для второго объявления. Вызов

f();

применим к любой из двух функций.

Упражнение 7.4

Какие из следующих объявлений содержат ошибки? Объясните.

(a) void print( int arr[][], int size );

(b) int ff( int a, int b = 0, int с = 0 );

(d) char *screenInit( int height = 24, int width,

char background );

(e) void putValues( int (&ia)[] );

Упражнение 7.5

Повторные объявления всех приведенных ниже функций содержат ошибки. Найдите их.

(a) char *screenInit( int height, int width,

                        char background = ' ' );

    char *screenInit( int height = 24, int width,

                        char background );

(b) void print( int (*arr)[6], int size );

    void print( int (*arr)[5], int size );

(c) void manip( int *pi, int first, int end = 0 );

void manip( int *pi, int first = 0, int end = 0 );

Упражнение 7.6

Даны объявления функций.

void print( int arr[][5], int size );

void operate(int *matrix[7]);

char *screenInit( int height = 24, int width = 80,

char background = ' ' );

Вызовы этих функций содержат ошибки. Найдите их и объясните.

(a) screenInit();

(b) int *matrix[5];

operate( matrix );

(c) int arr[5][5];

print( arr, 5 );

Упражнение 7.7

Перепишите функцию putValues( vector<int> ), приведенную в подразделе 7.3.4, так, чтобы она работала с контейнером list<string>. Печатайте по одному значению на строке. Вот пример вывода для списка из двух строк:

( 2 )

<

"first string"

"second string"

>

Напишите функцию main(), вызывающую новый вариант putValues() со следующим списком строк:

"put function declarations in header files"

"use abstract container types instead of built-in arrays"

"declare class parameters as references"

"use reference to const types for invariant parameters"

"use less than eight parameters"

Упражнение 7.8

В каком случае вы применили бы параметр-указатель? А в каком – параметр-ссылку? Опишите достоинства и недостатки каждого способа.

Множественное и виртуальное наследование

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

C++, – основная тема настоящей главы.

Множественное наследование

Для поддержки множественного наследования синтаксис списка базовых классов

class Bear : public ZooAnimal { ... };

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

class Panda : public Bear, public Endangered { ... };

Для каждого из перечисленных базовых классов должен быть указан уровень доступа: public, protected или private. Как и при одиночном наследовании, множественно наследовать можно только классу, определение которого уже встречалось ранее.

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

В случае множественного наследования объект производного класса содержит по одному подобъекту каждого из своих базовых (см. раздел 17.3). Например, когда мы пишем

Panda ying_yang;

то объект ying_yang

будет состоять из подобъекта класса Bear (который в свою очередь содержит подобъект ZooAnimal), подобъекта Endangered и нестатических членов, объявленных в самом классе Panda, если таковые есть (см. рис. 18.3).

ZooAnimal Endangered

Bear

Panda

Рис. 18.3. Иерархия множественного наследования класса Panda

Конструкторы базовых классов вызываются в порядке объявления в списке базовых классов. Например, для ying_yang эта последовательность такова: конструктор Bear (но поскольку класс Bear – производный от ZooAnimal, то сначала вызывается конструктор ZooAnimal), затем конструктор Endangered и в самом конце конструктор Panda.

Как отмечалось в разделе 17.4, на порядок вызова не

влияет ни наличие базовых классов в списке инициализации членов, ни порядок их перечисления. Иными словами, если бы конструктор Bear

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

// конструктор по умолчанию класса Bear вызывается до

// êîíñòðóêòîðà êëàññà Endangered ñ äâóìÿ àðãóìåíòàìè ...

Panda::Panda()

: Endangered( Endangered::environment,

Endangered::critical )

{ ... }

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

Порядок вызова деструкторов всегда противоположен порядку вызова конструкторов. В нашем примере деструкторы вызываются в такой последовательности: ~Panda(), ~Endangered(), ~Bear(), ~ZooAnimal().

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

Однако такую ошибку вызывает не потенциальная

неоднозначность неквалифицированного доступа к одному из двух одноименных членов, а лишь попытка фактического обращения к нему (см. раздел 17.4). Например, если в обоих классах Bear и Endangered определена функция-член print(), то инструкция

ying_yang.print( cout );

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

Error: ying_yang.print( cout ) -- ambiguous, one of

Bear::print( ostream& )

<

Endangered::print( ostream&, int )

Ошибка: ying_yang.print( cout ) -- неоднозначно, одна из

Bear::print( ostream& )

Endangered::print( ostream&, int )

Причина в том, что унаследованные функции- члены не образуют множество перегруженных функций внутри производного класса (см. раздел 17.3). Поэтому print()

разрешается только по имени, а не по типам фактических аргументов. (О том, как производится разрешение, мы поговорим в разделе 18.4.)

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

можно преобразовать в указатель, ссылку или объект ZooAnimal, Bear или Endangered:

extern void display( const Bear& );

extern void highlight( const Endangered& );

Panda ying_yang;

display( ying_yang ); // ïðàâèëüíî

highlight( ying_yang ); // ïðàâèëüíî

extern ostream&

operator<<( ostream&, const ZooAnimal& );

cout << ying_yang << endl; // правильно

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

extern void display( const Bear& );

extern void display( const Endangered& );

Неквалифицированный вызов display() для объекта класса Panda

Panda ying_yang;

display( ying_yang );   // ошибка: неоднозначность

приводит к ошибке компиляции:

Error: display( ying_yang ) -- ambiguous, one of

          display( const Bear& );

          display( const Endangered& );

Ошибка: display( ying_yang ) -- неоднозначно, одна из

          display( const Bear& );

          display( const Endangered& );

Компилятор не может различить два непосредственных базовых класса с точки зрения преобразования производного. Равным образом применимы обе трансформации. (Мы покажем способ разрешения этого конфликта в разделе 18.4.)

Чтобы понять, какое влияние оказывает множественное наследование на механизм виртуальных функций, определим их набор в каждом из непосредственных базовых классов Panda. (Виртуальные функции введены в разделе 17.2 и подробно обсуждались в разделе 17.5.)

class Bear : public ZooAnimal {

public:

   virtual ~Bear();

   virtual ostream& print( ostream& ) const;

   virtual string isA() const;

   // ...

};

class Endangered {

public:

   virtual ~Endangered();

   virtual ostream& print( ostream& ) const;

   virtual void highlight() const;

   // ...

};

Теперь определим в классе Panda

собственный экземпляр print(), собственный деструктор и еще одну виртуальную функцию cuddle():

class Panda : public Bear, public Endangered

{

public:

   virtual ~Panda();

   virtual ostream& print( ostream& ) const;

   virtual void cuddle();

   // ...

};

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

Таблица 18.1. Виртуальные функции для класса Panda

Имя виртуальной функции

Активный экземпляр

деструктор	Panda::~Panda()
print(ostream&) const	Panda::print(ostream&)
isA() const	Bear::isA()
highlight() const	Endangered::highlight()
cuddle()	Panda::cuddle()

Когда ссылка или указатель на объект Bear или ZooAnimal

инициализируется адресом объекта Panda или ему присваивается такой адрес, то части интерфейса, связанные с классами Panda и Endangered, становятся недоступны:

Bear *pb = new Panda;

pb->print( cout );      // ïðàâèëüíî: Panda::print(ostream&)

pb->isA();              // ïðàâèëüíî: Bear::isA()

pb->cuddle();           // îøèáêà: ýòî íå ÷àñòü èíòåðôåéñà Bear

pb->highlight();        // îøèáêà: ýòî íå ÷àñòü èíòåðôåéñà Bear

<

delete pb; // правильно: Panda::~Panda()

( Обратите внимание, что если бы объекту класса Panda был присвоен указатель на ZooAnimal, то все показанные выше вызовы разрешались бы так же.)

Аналогично, если ссылка или указатель на объект Endangered инициализируется адресом объекта Panda или ему присваивается такой адрес, то части интерфейса, связанные с классами Panda и Bear, становятся недоступными:

Endangered *pe = new Panda;

pe->print( cout ); // правильно: Panda::print(ostream&)

// îøèáêà: ýòî íå ÷àñòü èíòåðôåéñà Endangered

pe->cuddle();

pe->highlight(); // правильно: Endangered::highlight()

delete pe; // правильно: Panda::~Panda()

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

// ZooAnimal *pz = new Panda;

delete pz;

// Bear *pb = new Panda;

delete pb;

// Panda *pp = new Panda;

delete pp;

// Endangered *pe = new Panda;

delete pe;

Деструктор класса Panda

вызывается с помощью механизма виртуализации. После его выполнения по очереди статически вызываются деструкторы Endangered и Bear, а в самом конце – ZooAnimal.

Почленная инициализация и присваивание объекту производного класса, наследующего нескольким базовым, ведут себя точно так же, как и при одиночном наследовании (см. раздел 17.6). Например, для нашего объявления класса Panda

class Panda : public Bear, public Endangered

{ ... };

в результате почленной инициализации объекта ling_ling

Panda yin_yang;

Panda ling_ling = yin_yang;

вызывается копирующий конструктор класса Bear (но, так как Bear

производный от ZooAnimal, сначала выполняется копирующий конструктор класса ZooAnimal), затем – класса Endangered и только потом – класса Panda. Почленное присваивание ведет себя аналогично.

Упражнение 18.1

Какие из следующих объявлений ошибочны? Почему?

(a) class CADVehicle : public CAD, Vehicle { ... };

(b) class DoublyLinkedList:

public List, public List { ... };

private istream, private ostream { ... };

Упражнение 18.2

Дана иерархия, в каждом классе которой определен конструктор по умолчанию:

class A { ... };

class B : public A { ... };

class C : public B { ... };

class X { ... };

class Y { ... };

class Z : public X, public Y { ... };

class MI : public C, public Z { ... };

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

MI mi;

Упражнение 18.3

Дана иерархия, в каждом классе которой определен конструктор по умолчанию:

class X { ... };

class A { ... };

class B : public A { ... };

class C : private B { ... };

class D : public X, public C { ... };

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

D *pd = new D;

(a) X *px = pd; (c) B *pb = pd;

(b) A *pa = pd; (d) C *pc = pd;

Упражнение 18.4

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

class Base {

public:

   virtual ~Base();

   virtual ostream& print();

   virtual void debug();

   virtual void readOn();

   virtual void writeOn();

   // ...

};

class Derived1 : virtual public Base {

public:

   virtual ~Derived1();

   virtual void writeOn();

   // ...

};

class Derived2 : virtual public Base {

public:

   virtual ~Derived2();

   virtual void readOn();

   // ...

};

class MI : public Derived1, public Derived2 {

public:

   virtual ~MI();

   virtual ostream& print();

   virtual void debug();

   // ...

};

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

Base *pb = new MI;

(a) pb->print(); (c) pb->readOn(); (e) pb->log();

(b) pb->debug(); (d) pb->writeOn(); (f) delete pb;

Упражнение 18.5

На примере иерархии классов из упражнения 18.4 определите, какие виртуальные функции активны при вызове через pd1 и pd2:

(a) Derived1 *pd1 new MI;

(b) MI obj;

Derived2 d2 = obj;

Модель компиляции с включением

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

// model1.h

// модель с включением:

// определения шаблонов помещаются в заголовочный файл

template <typename Type>

Type min( Type t1, Type t2 ) {

return t1 < t2 ? t1 : t2;

}

Этот заголовочный файл включается в каждый файл, где конкретизируется функция min():

// определения шаблонов включены раньше

// используется конкретизация шаблона

#include "model1.h"

int i, j;

double dobj = min( i, j );

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

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

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

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

Модели компиляции шаблонов А

Шаблон функции задает алгоритм для построения определений множества экземпляров функций. Сам шаблон не определяет никакой функции. Например, когда компилятор видит шаблон:

template <typename Type>

Type min( Type t1, Type t2 )

{

return t1 < t2 ? t1 : t2;

}

он сохраняет внутреннее представление min(), но и только. Позже, когда встретится ее реальное использование, скажем:

int i, j;

double dobj = min( i, j );

компилятор строит определение min() по сохраненному внутреннему представлению.

Здесь возникает несколько вопросов. Чтобы компилятор мог конкретизировать шаблон функции, должно ли его определение быть видимо при вызове экземпляра этой функции? Например, нужно ли определению шаблона min() появиться до ее конкретизации c целыми параметрами при инициализации dobj? Следует ли помещать шаблоны в заголовочные файлы, как мы поступаем с определениями встроенных (inline) функций? Или в заголовочные файлы можно помещать только объявления шаблонов, оставляя определения в файлах исходных текстов?

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

Начинаем

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

Наилучшая из устоявших функций

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

· преобразование аргумента типа производного класса в параметр типа любого из его базовых;

· преобразование указателя на тип производного класса в указатель на тип любого из его базовых;

· инициализация ссылки на тип базового класса с помощью l-значения типа производного.

Они не являются пользовательскими, так как не зависят от конвертеров и конструкторов, имеющихся в классе:

extern void release( const ZooAnimal& );

Panda yinYang;

// стандартное преобразование: Panda -> ZooAnimal

release( yinYang );

Поскольку аргумент yinYang

типа Panda

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

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

class Panda : public Bear,

public Endangered

{

// наследует ZooAnimal::operator const char *()

};

Panda yinYang;

extern void release( const ZooAnimal& );

extern void release( const char * );

// стандартное преобразование: Panda -> ZooAnimal

// выбирается: release( const ZooAnimal& )

release( yinYang );

Как release(const char*), так и release(ZooAnimal&)

являются устоявшими функциями: первая потому, что инициализация параметра-ссылки значением аргумента – стандартное преобразование, а вторая потому, что аргумент можно привести к типу const char* с помощью конвертера ZooAnimal::operator const char*(), который представляет собой пользовательское преобразование. Так как стандартное преобразование лучше пользовательского, то в качестве наилучшей из устоявших выбирается функция release(const ZooAnimal&).

При ранжировании различных стандартных преобразований из производного класса в базовые лучшим считается приведение к тому базовому классу, который ближе к производному. Так, показанный ниже вызов не будет неоднозначным, хотя в обоих случаях требуется стандартное преобразование. Приведение к базовому классу Bear

лучше, чем к ZooAnimal, поскольку Bear

ближе к классу Panda. Поэтому лучшей из устоявших будет функция release(const Bear&):

extern void release( const ZooAnimal& );

extern void release( const Bear& );

// правильно: release( const Bear& )

release( yinYang );

Аналогичное правило применимо и к указателям. При ранжировании стандартных преобразований из указателя на тип производного класса в указатели на типы различных базовых лучшим считается то, для которого базовый класс наименее удален от производного. Это правило распространяется и на тип void*.

Стандартное преобразование в указатель на тип любого базового класса всегда лучше, чем преобразование в void*. Например, если дана пара перегруженных функций:

void receive( void* );

void receive( ZooAnimal* );

то наилучшей из устоявших для вызова с аргументом типа Panda* будет receive(ZooAnimal*).

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

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

extern void mumble( const Bear& );

extern void mumble( const Endangered& );

/* ошибка: неоднозначный вызов:

* может быть выбрана любая из двух функций

* void mumble( const Bear& );

* void mumble( const Endangered& );

*/

mumble( yinYang );

Для разрешения неоднозначности программист может применить явное приведение типа:

mumble( static_cast< Bear >( yinYang ) ); // правильно

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

extern void release( const Bear& );

extern void release( const Panda& );

ZooAnimal za;

// ошибка: нет соответствия

release( za );

В следующем примере наилучшей из устоявших будет release(const char*). Это может показаться удивительным, так как к аргументу применена последовательность пользовательских преобразований, в которой участвует конвертер const char*(). Но поскольку неявного приведения от типа базового класса к типу производного не существует, то release(const Bear&) не является устоявшей функцией, так что остается только release(const char*):

Class ZooAnimal {

public:

   // преобразование: ZooAnimal ==> const char*

   operator const char*();

   // ...

};

extern void release( const char* );

extern void release( const Bear& );

ZooAnimal za;

// za ==> const char*

// правильно: release( const char* )

release( za );Ошибка! Закладка не определена.Ошибка! Закладка не определена.Ошибка! Закладка не определена.

Упражнение 19.9

Дана такая иерархия классов:

class Base1 {

public:

   ostream& print();

   void debug();

   void writeOn();

   void log( string );

   void reset( void *);

   // ...

};

class Base2 {

public:

   void debug();

   void readOn();

   void log( double );

   // ...

};

class MI : public Base1, public Base2 {

public:

   ostream& print();

   using Base1::reset;

   void reset( char * );

   using Base2::log;

   using Base2::log;

   // ...

<

};

Какие функции входят в множество кандидатов для каждого из следующих вызовов:

MI *pi = new MI;

(a) pi->print(); (c) pi->readOn(); (e) pi->log( num );

(b) pi->debug(); (d) pi->reset(0); (f) pi->writeOn();

Упражнение 19.10

Дана такая иерархия классов:

class Base {

public:

   operator int();

   operator const char *();

   // ...

};

class Derived : public Base {

public:

   operator double();

   // ...

};

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

(a) void operate( double );

    void operate( string );

    void operate( const Base & );

    Derived *pd = new Derived;

operate( *pd );

(b) void calc( int );

    void calc( double );

    void calc( const Derived & );

    Base *pb = new Derived;

operate( *pb );

20

Наилучшая из устоявших функция

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

преобразования, примененные к аргументам, не хуже

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

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

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

int arr[3];

void putValues(const int *);

int main() {

putValues(arr); // необходимо 2 преобразования

// массив в указатель + преобразование спецификатора

return 0;

}

для приведения аргумента arr от типа “массив из трех int” к типу “указатель на const int” применяется последовательность преобразований:

1. Преобразование массива в указатель, которое трансформирует массив из трех int в указатель на int.

2. Преобразование спецификатора, которое трансформирует указатель на int в указатель на const int.

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

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

Такая совокупность состоит из нескольких преобразований, применяемых в указанном порядке:

преобразование l-значения ->

расширение типа или стандартное преобразование ->

преобразование спецификаторов

Термин преобразование l-значения

относится к первым трем трансформациям из категории точных соответствий, рассмотренных в разделе 9.2: преобразование l-значения в r-значение, преобразование массива в указатель и преобразование функции в указатель. Последовательность трансформаций состоит из нуля или одного преобразования l-значения, за которым следует нуль или одно расширение типа или стандартное преобразование, и наконец нуль или одно преобразование спецификаторов. Для приведения фактического аргумента к типу формального параметра может быть применено только одна трансформация каждого вида.

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

Каковы последовательности изменений фактических аргументов в следующем примере?

namespace libs_R_us {

   int max( int, int );

   double max( double, double );

}

// using-объявление

using libs_R_us::max;

void func()

{

   char c1, c2;

   max( c1, c2 );   // вызывается libs_R_us::max( int, int )

}

Аргументы в вызове функции max()

имеют тип char. Последовательность преобразований аргументов при вызове функции libs_R_us::max(int,int)

следующая:

1a.       Так как аргументы передаются по значению, то с помощью преобразования l-значения в r-значение извлекаются значения аргументов c1 и c2.

2a.       С помощью расширения типа аргументы трансформируются из char в int.

Последовательность преобразований аргументов при вызове функции libs_R_us::max(double,double)

следующая:

1b.       С помощью преобразования l-значения в r-значение извлекаются значения аргументов c1 и c2.

2b.       Стандартное преобразование между целым и плавающим типом приводит аргументы от типа char к типу double.

Ранг первой последовательности – расширение типа (самое худшее из примененных изменений), тогда как ранг второй – стандартное преобразование. Так как расширение типа лучше, чем преобразование, то в качестве наилучшей из устоявших для данного вызова выбирается функция libs_R_us::max(int,int).

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

требуется такая последовательность:

1.      Преобразование l-значения в r-значение для извлечения значений аргументов i и j.

2.      Стандартное преобразование для приведения типов фактических аргументов к типам соответствующих формальных параметров.

Поскольку нельзя сказать, какая из этих последовательностей лучше другой, вызов неоднозначен:

int i, j;

extern long calc( long, long );

extern double calc( double, double );

void jj() {

// ошибка: неоднозначность, нет наилучшего соответствия

calc( i, j );

}

Преобразование спецификаторов (добавление спецификатора const или volatile к типу, который адресует указатель) имеет ранг точного соответствия. Однако, если две последовательности трансформаций отличаются только тем, что в конце одной из них есть дополнительное преобразование спецификаторов, то последовательность без него считается лучше. Например:

void reset( int * );

void reset( const int * );

int* pi;

int main() {

   reset( pi );   // без преобразования спецификаторов лучше:

                  // выбирается reset( int * )

   return 0;

}

Последовательность стандартных преобразований, примененная к фактическому аргументу для первой функции-кандидата reset(int*), – это точное соответствие, требуется лишь переход от l-значения к r-значению, чтобы извлечь значение аргумента. Для второй функции-кандидата reset(const int *)

также применяется трансформация l-значения в r-значение, но за ней следует еще и преобразование спецификаторов для приведения результирующего значения от типа “указатель на int” к типу “указатель на const int”. Обе последовательности представляют собой точное соответствие, но неоднозначности при этом не возникает. Так как вторая последовательность отличается от первой наличием трансформации спецификаторов в конце, то последовательность без такого преобразования считается лучшей. Поэтому наилучшей из устоявших функций будет reset(int*).

Вот еще пример, в котором приведение спецификаторов влияет на то, какая последовательность будет выбрана:

int extract( void * );

int extract( const void * );

int* pi;

int main() {

extract( pi ); // выбирается extract( void * )

return 0;

}

Здесь для вызова есть две устоявших функции: extract(void*) и extract(const void*). Последовательность преобразований для функции extract(void*)

состоит из трансформации l-значения в r-значение для извлечения значения аргумента, сопровождаемого стандартным преобразованием указателя: из указателя на int в указатель на void. Для функции extract(const void*)

такая последовательность отличается от первой дополнительным преобразованием спецификаторов для приведения типа результата от указателя на void к указателю на const void. Поскольку последовательности различаются лишь этой трансформацией, то первая выбирается как более подходящая и, следовательно, наилучшей из устоявших будет функция extract(const void*).

Спецификаторы const и volatile

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

#include <vector>

void manip( vector<int> & );

void manip( const vector<int> & );

vector<int> f();

extern vector<int> vec;

int main() {

   manip( vec );   // выбирается manip( vector<int> & )

   manip( f() ); // выбирается manip( const vector<int> & )

   return 0;

<

}

В первом вызове инициализация ссылок для вызова любой функции является точным соответствием. Но этот вызов все же не будет неоднозначным. Так как обе инициализации одинаковы во всем, кроме наличия дополнительной спецификации const во втором случае, то инициализация без такой спецификации считается лучше, поэтому перегрузка будет разрешена в пользу устоявшей функции manip(vector<int>&).

Для второго вызова существует только одна устоявшая функция manip(const vector<int>&). Поскольку фактический аргумент является временной переменной, содержащей результат, возвращенный f(), то такой аргумент представляет собой r-значение, которое нельзя использовать для инициализации неконстантного формального параметра-ссылки функции manip(vector<int>&). Поэтому наилучшей является единственная устоявшая manip(const vector<int>&).

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

extern int ff( char*, int );

extern int ff( int, int );

int main() {

ff( 0, 'a' ); // ff( int, int )

return 0;

}

Функция ff(), принимающая два аргумента типа int, выбирается в качестве наилучшей из устоявших по следующим причинам:

1. ее первый аргумент лучше. 0

дает точное соответствие с формальным параметром типа int, тогда как для установления соответствия с параметром типа char *

требуется стандартное преобразование указателя;

2. ее второй аргумент имеет тот же ранг. К аргументу 'a'

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

Вот еще один пример:

int compute( const int&, short );

int compute( int&, double );

extern int iobj;

int main() {

compute( iobj, 'c' ); // compute( int&, double )

return 0;

}

Обе функции compute( const int&, short ) и compute( int&, double )

устояли. Вторая выбирается в качестве наилучшей по следующим причинам:

1. ее первый аргумент лучше. Инициализация ссылки для первой устоявшей функции хуже потому, что она требует добавления спецификатора const, не нужного для второй функции;

2. ее второй аргумент имеет тот же ранг. К аргументу 'c'

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

Наследование и композиция

Реализация класса PeekbackStack с помощью закрытого наследования от IntArray работает, но необходимо ли это? Помогло ли нам наследование в данном случае? Нет.

Открытое наследование – это мощный механизм для поддержки отношения “ЯВЛЯЕТСЯ”. Однако реализация PeekbackStack по отношению к IntArray – пример отношения “СОДЕРЖИТ”. Класс PeekbackStack содержит класс IntArray как часть своей реализации. Отношение “СОДЕРЖИТ”, как правило, лучше поддерживается с помощью композиции, а не наследования. Для ее реализации надо один класс сделать членом другого. В нашем случае объект IntArray

делается членом PeekbackStack. Вот реализация PeekbackStack на основе композиции:

class PeekbackStack {

private:

const int static bos = -1;

public:

explicit PeekbackStack( int size ) :

stack( size ), _top( bos ) {}

bool empty() const { return _top == bos; }

bool full() const { return _top == size()-1; }

int top() const { return _top; }

int pop() {

if ( empty() )

/* обработать ошибку */ ;

return stack[ _top-- ];

}

void push( int value ) {

if ( full() )

/* обработать ошибку */ ;

stack[ ++_top ] = value;

}

bool peekback( int index, int &value ) const;

private:

int _top;

IntArray stack;

};

inline bool

PeekbackStack::

peekback( int index, int &value ) const

{

if ( empty() )

/* обработать ошибку */ ;

if ( index < 0 || index > _top )

{

value = stack[ _top ];

return false;

}

value = stack[ index ];

return true;

}

Решая, следует ли использовать при проектировании класса с отношением “СОДЕРЖИТ” композицию или закрытое наследование, можно руководствоваться такими соображениями:

· если мы хотим заместить какие-либо виртуальные функции базового класса, то должны закрыто наследовать ему;

· если мы хотим разрешить нашему классу ссылаться на класс из иерархии типов, то должны использовать композицию по ссылке (мы подробно расскажем о ней в разделе 18.3.4);

· если, как в случае с классом PeekbackStack, мы хотим воспользоваться готовой реализацией, то композиция по значению предпочтительнее наследования. Если требуется отложенное выделение памяти для объекта, то следует выбрать композицию по ссылке (с помощью указателя).