Оператор “запятая”
Одно выражение может состоять из набора подвыражений, разделенных запятыми; такие подвыражения вычисляются слева направо. Конечным результатом будет результат самого правого из них. В следующем примере каждое из подвыражений условного оператора представляет собой список. Результатом первого подвыражения условного оператора является ix, второго– 0.
int main()
{
// примеры оператора "запятая"
// переменные ia, sz и index определены в другом месте ...
int ival = (ia != 0)
? ix=get_va1ue(), ia[index]=ix
: ia=new int[sz], ia[index]=0;
// ...
}
Операторные функции-кандидаты
Операторная функция является кандидатом, если она имеет то же имя, что и вызванная. При использовании следующего оператора сложения
SmallInt si(98);
int iobj = 65;
int res = si + iobj;
операторной функцией-кандидатом является operator+. Какие объявления operator+ принимаются во внимание?
Потенциально в случае применения операторного синтаксиса с операндами, имеющими тип класса, строится пять множеств кандидатов. Первые три– те же, что и при вызове обычных функций с аргументами типа класса:
множество операторов, видимых в точке вызова. Объявления функции operator+(), видимые в точке использования оператора, являются кандидатами. Например, operator+(), объявленный в глобальной области видимости, – кандидат в случае применения operator+() внутри main():
SmallInt operator+ ( const SmallInt &, const SmallInt & );
int main() {
SmallInt si(98);
int iobj = 65;
int res = si + iobj; // ::operator+() - функция-кандидат
}
множество операторов, объявленных в пространстве имен, в котором определен тип операнда. Если операнд имеет тип класса и этот тип объявлен в пользовательском пространстве имен, то операторные функции, объявленные в том же пространстве и имеющие то же имя, что и использованный оператор, считаются кандидатами:
namespace NS {
class SmallInt { /* ... */ };
SmallInt operator+ ( const SmallInt&, double );
}
int main() {
// si имеет тип SmallInt:
// этот класс объявлен в пространстве имен NS
NS::SmallInt si(15);
// NS::operator+() - функция-кандидат
int res = si + 566;
return 0;
}
Операнд si имеет тип класса SmallInt, объявленного в пространстве имен NS. Поэтому перегруженный operator+(const SmallInt, double), объявленный в том же пространстве, добавляется к множеству кандидатов;
множество операторов, объявленных друзьями классов, к которым принадлежат операнды. Если операнд принадлежит к типу класса и в определении этого класса есть одноименные применяемому оператору функции-друзья, то они добавляются к множеству кандидатов:
namespace NS {
class SmallInt {
friend SmallInt operator+( const SmallInt&, int )
{ /* ... */ }
};
}
int main() {
NS::SmallInt si(15);
// функция-друг operator+() - кандидат
int res = si + 566;
return 0;
}
Операнд si имеет тип SmallInt. Операторная функция operator+(const SmallInt&, int), являющаяся другом этого класса, – член пространства имен NS, хотя непосредственно в этом пространстве она не объявлена. При обычном поиске в NS эта операторная функция не будет найдена. Однако при использовании operator+() с аргументом типа SmallInt функции-друзья, объявленные в области видимости этого класса, включаются в рассмотрение и добавляются к множеству кандидатов.
Эти три множества операторных функций-кандидатов формируются точно так же, как и для вызовов обычных функций с аргументами типа класса. Однако при использовании операторного синтаксиса строятся еще два множества:
множество операторов-членов, объявленных в классе левого операнда. Если такой операнд оператора operator+() имеет тип класса, то в множество функций-кандидатов включаются объявления operator+(), являющиеся членами этого класса:
class myFloat {
myFloat( double );
};
class SmallInt {
public:
SmallInt( int );
SmallInt operator+ ( const myFloat & );
};
int main() {
SmallInt si(15);
int res = si + 5.66; // оператор-член operator+() - кандидат
}
Оператор-член SmallInt::operator+(const myFloat &), определенный в SmallInt, включается в множество функций-кандидатов для разрешения вызова operator+() в main();
множество встроенных операторов. Учитывая типы, которые можно использовать со встроенным operator+(), кандидатами являются также:
int operator+( int, int );
double operator+( double, double );
T* operator+( T*, I );
T* operator+( I, T* );
Первое объявление относится к встроенному оператору для сложения двух значений целых типов, второе – к оператору для сложения значений типов с плавающей точкой. Третье и четвертое соответствуют встроенному оператору сложения указательных типов, который используется для прибавления целого числа к указателю. Два последних объявления представлены в символическом виде и описывают целое семейство встроенных операторов, которые могут быть выбраны компилятором на роль кандидатов при обработке операций сложения.
Любое из первых четырех множеств может оказаться пустым. Например, если среди членов класса SmallInt нет функции с именем operator+(), то четвертое множество будет пусто.
Все множество операторных функций-кандидатов является объединением пяти подмножеств, описанных выше:
namespace NS {
class myFloat {
myFloat( double );
};
class SmallInt {
friend SmallInt operator+( const SmallInt &, int ) { /* ... */ }
public:
SmallInt( int );
operator int();
SmallInt operator+ ( const myFloat & );
// ...
};
SmallInt operator+ ( const SmallInt &, double );
}
int main() {
// тип si - class SmallInt:
// Этот класс объявлен в пространстве имен NS
NS::SmallInt si(15);
int res = si + 5.66; // какой operator+()?
return 0;
}
В эти пять множеств входят семь операторных функций-кандидатов на роль operator+() в main():
первое множество пусто. В глобальной области видимости, а именно в ней употреблен operator+() в функции main(), нет объявлений перегруженного оператора operator+();
второе множество содержит операторы, объявленные в пространстве имен NS, где определен класс SmallInt. В этом пространстве имеется один оператор:
NS::SmallInt NS::operator+( const SmallInt &, double );
третье множество содержит операторы, объявленные друзьями класса SmallInt. Сюда входит
NS::SmallInt NS::operator+( const SmallInt &, int );
четвертое множество содержит операторы, объявленные членами SmallInt. Такой тоже есть:
NS::SmallInt NS::SmallInt::operator+( const myFloat & );
пятое множество содержит встроенные бинарные операторы:
int operator+( int, int );
double operator+( double, double );
T* operator+( T*, I );
T* operator+( I, T* );
Да, формирование множества кандидатов для разрешения оператора, использованного с применением операторного синтаксиса, утомительно. Но после того как оно построено, устоявшие функции и наилучшая из них находятся, как и прежде, путем анализа преобразований, применимых к операндам отобранных кандидатов.
Операторы инкремента и декремента
Продолжая развивать реализацию класса ScreenPtr, введенного в предыдущем разделе, рассмотрим еще два оператора, которые поддерживаются для встроенных указателей и которые желательно иметь и для нашего интеллектуального указателя: инкремент (++) и декремент (--). Чтобы использовать класс ScreenPtr для ссылки на элементы массива объектов Screen, туда придется добавить несколько дополнительных членов.
Сначала мы определим новый член size, который содержит либо нуль (это говорит о том, что объект ScreenPtr указывает на единственный объект), либо размер массива, адресуемого объектом ScreenPtr. Нам также понадобится член offset, запоминающий смещение от начала данного массива:
class ScreenPtr {
public:
// ...
private:
int size; // размер массива: 0, если единственный объект
int offset; // смещение ptr от начала массива
Screen *ptr;
};
Модифицируем конструктор класса ScreenPtr с учетом его новой функциональности и дополнительных членов,. Пользователь нашего класса должен передать конструктору дополнительный аргумент, если создаваемый объект указывает на массив:
class ScreenPtr {
public:
ScreenPtr( Screen &s , int arraySize = 0 )
: ptr( &s ), size ( arraySize ), offset( 0 ) { }
private:
int size;
int offset;
Screen *ptr;
};
С помощью этого аргумента задается размер массива. Чтобы сохранить прежнюю функциональность, предусмотрим для него значение по умолчанию, равное нулю. Таким образом, если второй аргумент конструктора опущен, то член size окажется равен 0 и, следовательно, такой объект будет указывать на единственный объект Screen. Объекты нового класса ScreenPtr можно определять следующим образом:
Screen myScreen( 4, 4 );
ScreenPtr pobj( myScreen ); // правильно: указывает на один объект
const int arrSize = 10;
Screen *parray = new Screen[ arrSize ];
ScreenPtr parr( *parray, arrSize ); // правильно: указывает на массив
Теперь мы готовы определить в ScreenPtr перегруженные операторы инкремента и декремента. Однако они бывают двух видов: префиксные и постфиксные. К счастью, можно определить оба варианта. Для префиксного оператора объявление не содержит ничего неожиданного:
class ScreenPtr {
public:
Screen& operator++();
Screen& operator--();
// ...
};
Такие операторы определяются как унарные операторные функции. Использовать префиксный оператор инкремента можно, к примеру, следующим образом:
const int arrSize = 10;
Screen *parray = new Screen[ arrSize ];
ScreenPtr parr( *parray, arrSize );
for ( int ix = 0;
ix < arrSize;
++ix, ++parr ) // эквивалентно parr.operator++()
}
printScreen( parr );
Определения этих перегруженных операторов приведены ниже:
Screen& ScreenPtr::operator++()
{
if ( size == 0 ) {
cerr << "не могу инкрементировать указатель для одного объекта\n";
return *ptr;
}
if ( offset >= size - 1 ) {
cerr << "уже в конце массива\n";
return *ptr;
}
++offset;
return *++ptr;
}
Screen& ScreenPtr::operator--()
{
if ( size == 0 ) {
cerr << "не могу декрементировать указатель для одного объекта\n";
return *ptr;
}
if ( offset <= 0 ) {
cerr << "уже в начале массива\n";
return *ptr;
}
--offset;
return *--ptr;
}
Чтобы отличить префиксные операторы от постфиксных, в объявлениях последних имеется дополнительный параметр типа int. В следующем фрагменте объявлены префиксные и постфиксные варианты операторов инкремента и декремента для класса ScreenPtr:
class ScreenPtr {
public:
Screen& operator++(); // префиксные операторы
Screen& operator--();
Screen& operator++(int); // постфиксные операторы
Screen& operator--(int);
// ...
};
Ниже приведена возможная реализация постфиксных операторов:
Screen& ScreenPtr::operator++(int)
{
if ( size == 0 ) {
cerr << "не могу инкрементировать указатель для одного объекта\n";
return *ptr;
}
if ( offset == size ) {
cerr << "уже на один элемент дальше конца массива\n";
return *ptr;
}
++offset;
return *ptr++;
}
Screen& ScreenPtr::operator--(int)
{
if ( size == 0 ) {
cerr << " не могу декрементировать указатель для одного объекта\n";
return *ptr;
}
if ( offset == -1 ) {
cerr << "уже на один элемент раньше начала массива\n";
return *ptr;
}
--offset;
return *ptr--;
}
Обратите внимание, что давать название второму параметру нет необходимости, поскольку внутри определения оператора он не употребляется. Компилятор сам подставляет для него значение по умолчанию, которое можно игнорировать. Вот пример использования постфиксного оператора:
const int arrSize = 10;
Screen *parray = new Screen[ arrSize ];
ScreenPtr parr( *parray, arrSize );
for ( int ix = 0; ix < arrSize; ++ix)
printScreen( parr++ );
При его явном вызове необходимо все же передать значение второго целого аргумента. В случае нашего класса ScreenPtr это значение игнорируется, поэтому может быть любым:
parr.operator++(1024); // вызов постфиксного operator++
Перегруженные операторы инкремента и декремента разрешается объявлять как дружественные функции. Изменим соответствующим образом определение класса ScreenPtr:
class ScreenPtr {
// объявления не членов
friend Screen& operator++( Screen & ); // префиксные операторы
friend Screen& operator--( Screen & );
friend Screen& operator++( Screen &, int); // постфиксные операторы
friend Screen& operator--( Screen &, int);
public:
// определения членов
};
Упражнение 15.7
Напишите определения перегруженных операторов инкремента и декремента для класса ScreenPtr, предположив, что они объявлены как друзья класса.
Упражнение 15.8
С помощью ScreenPtr можно представить указатель на массив объектов класса Screen. Модифицируйте перегруженные operator*() и operator?>() (см. раздел 15.6) так, чтобы указатель ни при каком условии не адресовал элемент перед началом или за концом массива. Совет: в этих операторах следует воспользоваться новыми членами size и offset.
Операторы new и delete
Каждая программа во время работы получает определенное количество памяти, которую можно использовать. Такое выделение памяти под объекты во время выполнения называется динамическим, а сама память выделяется из хипа (heap). (Мы уже касались вопроса о динамическом выделении памяти в главе 1.) Напомним, что выделение памяти объекту производится с помощью оператора new, возвращающего указатель на вновь созданный объект того типа, который был ему задан. Например:
int *pi = new int;
размещает объект типа int в памяти и инициализирует указатель pi адресом этого объекта. Сам объект в таком случае не инициализируется, но это легко изменить:
int *pi = new int( 1024 );
Можно динамически выделить память под массив:
int *pia = new int[ 10 ];
Такая инструкция размещает в памяти массив встроенного типа из десяти элементов типа int. Для подобного массива нельзя задать список начальных значений его элементов при динамическом размещении. (Однако если размещается массив объектов типа класса, то для каждого из элементов вызывается конструктор по умолчанию.) Например:
string *ps = new string;
размещает в памяти один объект типа string, инициализирует ps его адресом и вызывает конструктор по умолчанию для вновь созданного объекта типа string. Аналогично
string *psa = new string[10];
размещает в памяти массив из десяти элементов типа string, инициализирует psa его адресом и вызывает конструктор по умолчанию для каждого элемента массива.
Объекты, размещаемые в памяти с помощью оператора new, не имеют собственного имени. Вместо этого возвращается указатель на безымянный объект, и все действия с этим объектом производятся посредством косвенной адресации.
После использования объекта, созданного таким образом, мы должны явно освободить память, применив оператор delete к указателю на этот объект. (Попытка применить оператор delete к указателю, не содержащему адрес объекта, полученного описанным способом, вызовет ошибку времени выполнения.) Например:
delete pi;
освобождает память, на которую указывает объект типа int, на который указывает pi. Аналогично
delete ps;
освобождает память, на которую указывает объект класса string, адрес которого содержится в ps. Перед уничтожением этого объекта вызывается деструктор. Выражение
delete [] pia;
освобождает память, отведенную под массив pia. При выполнении такой операции необходимо придерживаться указанного синтаксиса.
(Об операциях new и delete мы еще поговорим в главе 8.)
Упражнение 4.11
Какие из следующих выражений ошибочны?
(a) vector<string> svec( 10 );
(b) vector<string> *pvecl = new vector<string>(10);
(c) vector<string> **pvec2 = new vector<string>[10];
(d) vector<string> *pvl = &svec;
(e) vector<string> *pv2 = pvecl;
(f) delete svec;
(g) delete pvecl;
(h) delete [] pvec2;
(i) delete pvl;
(j) delete pv2;
Операторы new и delete
По умолчанию выделение объекта класса из хипа и освобождение занятой им памяти выполняются с помощью глобальных операторов new() и delete(), определенных в стандартной библиотеке C++. (Мы рассматривали эти операторы в разделе 8.4.) Но класс может реализовать и собственную стратегию управления памятью, предоставив одноименные операторы-члены. Если они определены в классе, то вызываются вместо глобальных операторов с целью выделения и освобождения памяти для объектов этого класса.
Определим операторы new() и delete() в нашем классе Screen.
Оператор-член new() должен возвращать значение типа void* и принимать в качестве первого параметра значение типа size_t, где size_t– это typedef, определенный в системном заголовочном файле <cstddef>. Вот его объявление:
class Screen {
public:
void *operator new( size_t );
// ...
};
Когда для создания объекта типа класса используется new(), компилятор проверяет, определен ли в этом классе такой оператор. Если да, то для выделения памяти под объект вызывается именно он, в противном случае – глобальный оператор new(). Например, следующая инструкция
Screen *ps = new Screen;
создает объект Screen в хипе, а поскольку в этом классе есть оператор new(), то вызывается он. Параметр size_t оператора автоматически инициализируется значением, равным размеру Screen в байтах.
Добавление оператора new() в класс или его удаление оттуда не отражаются на пользовательском коде. Вызов new выглядит одинаково как для глобального оператора, так и для оператора-члена. Если бы в классе Screen не было собственного new(), то обращение осталось бы правильным, только вместо оператора-члена вызывался бы глобальный оператор.
С помощью оператора разрешения глобальной области видимости можно вызвать глобальный new(), даже если в классе Screen определена собственная версия:
Screen *ps = ::new Screen;
Оператор delete(), являющийся членом класса, должен иметь тип void, а в качестве первого параметра принимать void*. Вот как выглядит его объявление для Screen:
class Screen {
public:
void operator delete( void * );
};
Когда операндом delete служит указатель на объект типа класса, компилятор проверяет, определен ли в этом классе оператор delete(). Если да, то для освобождения памяти вызывается именно он, в противном случае – глобальная версия оператора. Следующая инструкция
delete ps;
освобождает память, занятую объектом класса Screen, на который указывает ps. Поскольку в Screen есть оператор-член delete(), то применяется именно он. Параметр оператора типа void* автоматически инициализируется значением ps.
Добавление delete() в класс или его удаление оттуда никак не сказываются на пользовательском коде. Вызов delete выглядит одинаково как для глобального оператора, так и для оператора-члена. Если бы в классе Screen не было собственного оператора delete(), то обращение осталось бы правильным, только вместо оператора-члена вызывался бы глобальный оператор.
С помощью оператора разрешения глобальной области видимости можно вызвать глобальный delete(), даже если в Screen определена собственная версия:
::delete ps;
В общем случае используемый оператор delete() должен соответствовать тому оператору new(), с помощью которого была выделена память. Например, если ps указывает на область памяти, выделенную глобальным new(), то для ее освобождения следует использовать глобальный же delete().
Оператор delete(), определенный для типа класса, может содержать два параметра вместо одного. Первый параметр по-прежнему должен иметь тип void*, а второй – предопределенный тип size_t (не забудьте включить заголовочный файл <cstddef>):
class Screen {
public:
// заменяет
// void operator delete( void * );
void operator delete( void *, size_t );
};
Если второй параметр есть, компилятор автоматически инициализирует его значением, равным размеру адресованного первым параметром объекта в байтах. (Этот параметр важен в иерархии классов, когда оператор delete() может наследоваться производным классом. Подробнее наследование обсуждается в главе 17.)
Рассмотрим реализацию операторов new() и delete() в классе Screen более детально. В основе нашей стратегии распределения памяти будет лежать связанный список объектов Screen, на начало которого указывает член freeStore. При каждом обращении к оператору-члену new() возвращается следующий объект из списка. При вызове delete() объект возвращается в список. Если при создании нового объекта список, адресованный freeStore, пуст, то вызывается глобальный оператор new(), чтобы получить блок памяти, достаточный для хранения screenChunk объектов класса Screen.
Как screenChunk, так и freeStore представляют интерес только для Screen, поэтому мы сделаем их закрытыми членами. Кроме того, для всех создаваемых объектов нашего класса значения этих членов должны быть одинаковыми, а следовательно, нужно объявить их статическими. Чтобы поддержать структуру связанного списка объектов Screen, нам понадобится третий член next:
class Screen {
public:
void *operator new( size_t );
void operator delete( void *, size_t );
// ...
private:
Screen *next;
static Screen *freeStore;
static const int screenChunk;
};
Вот одна из возможных реализаций оператора new() для класса Screen:
#include "Screen.h"
#include <cstddef>
// статические члены инициализируются
// в исходных файлах программы, а не в заголовочных файлах
Screen *Screen::freeStore = 0;
const int Screen::screenChunk = 24;
void *Screen::operator new( size_t size )
{
Screen *p;
if ( !freeStore ) {
// связанный список пуст: получить новый блок
// вызывается глобальный оператор new
size_t chunk = screenChunk * size;
freeStore = p =
reinterpret_cast< Screen* >( new char[ chunk ] );
// включить полученный блок в список
for ( ;
p != &freeStore[ screenChunk - 1 ];
++p )
p->next = p+1;
p->next = 0;
}
p = freeStore;
freeStore = freeStore->next;
return p;
}
А вот реализация оператора delete():
void Screen::operator delete( void *p, size_t )
{
// вставить "удаленный" объект назад,
// в список свободных
( static_cast< Screen* >( p ) )->next = freeStore;
freeStore = static_cast< Screen* >( p );
}
Оператор new() можно объявить в классе и без соответствующего delete(). В таком случае объекты освобождаются с помощью одноименного глобального оператора. Разрешается также объявить и оператор delete() без new(): объекты будут создаваться с помощью одноименного глобального оператора. Однако обычно эти операторы реализуются одновременно, как в примере выше, поскольку разработчику класса, как правило, нужны оба.
Они являются статическими членами класса, даже если программист явно не объявит их таковыми, и подчиняются обычным ограничениями для подобных функций-членов: им не передается указатель this, а следовательно, напрямую они могут получить доступ только к статическим членам. (См. обсуждение статических функций-членов в разделе 13.5.) Причина, по которой эти операторы делаются статическими, заключается в том, что они вызываются либо перед конструированием объекта класса (new()), либо после его уничтожения (delete()).
Выделение памяти с помощью оператора new(), например:
Screen *ptr = new Screen( 10, 20 );
эквивалентно последовательному выполнению таких инструкций:
// Псевдокод на C++
ptr = Screen::operator new( sizeof( Screen ) );
Screen::Screen( ptr, 10, 20 );
Иными словами, сначала вызывается определенный в классе оператор new(), чтобы выделить память для объекта, а затем этот объект инициализируется конструктором. Если new() неудачно завершает работу, то возбуждается исключение типа bad_alloc и конструктор не вызывается.
Освобождение памяти с помощью оператора delete(), например:
delete ptr;
эквивалентно последовательному выполнению таких инструкций:
// Псевдокод на C++
Screen::~Screen( ptr );
Screen::operator delete( ptr, sizeof( *ptr ) );
Таким образом, при уничтожении объекта сначала вызывается деструктор класса, а затем определенный в классе оператор delete() для освобождения памяти. Если значение ptr равно 0, то ни деструктор, ни delete() не вызываются.
Операторы new[ ] и delete [ ]
Оператор new(), определенный в предыдущем подразделе, вызывается только при выделении памяти для единичного объекта. Так, в данной инструкции вызывается new() класса Screen:
// вызывается Screen::operator new()
Screen *ps = new Screen( 24, 80 );
тогда как ниже вызывается глобальный оператор new[]() для выделения из хипа памяти под массив объектов типа Screen:
// вызывается Screen::operator new[]()
Screen *psa = new Screen[10];
В классе можно объявить также операторы new[]() и delete[]() для работы с массивами.
Оператор-член new[]() должен возвращать значение типа void* и принимать в качестве первого параметра значение типа size_t. Вот его объявление для Screen:
class Screen {
public:
void *operator new[]( size_t );
// ...
};
Когда с помощью new создается массив объектов типа класса, компилятор проверяет, определен ли в классе оператор new[](). Если да, то для выделения памяти под массив вызывается именно он, в противном случае – глобальный new[](). В следующей инструкции в хипе создается массив из десяти объектов Screen:
Screen *ps = new Screen[10];
В этом классе есть оператор new[](), поэтому он и вызывается для выделения памяти. Его параметр size_t автоматически инициализируется значением, равным объему памяти в байтах, необходимому для размещения десяти объектов Screen.
Даже если в классе имеется оператор-член new[](), программист может вызвать для создания массива глобальный new[](), воспользовавшись оператором разрешения глобальной области видимости:
Screen *ps = ::new Screen[10];
Оператор delete(), являющийся членом класса, должен иметь тип void, а в качестве первого параметра принимать void*. Вот как выглядит его объявление для Screen:
class Screen {
public:
void operator delete[]( void * );
};
Чтобы удалить массив объектов класса, delete должен вызываться следующим образом:
delete[] ps;
Когда операндом delete является указатель на объект типа класса, компилятор проверяет, определен ли в этом классе оператор delete[](). Если да, то для освобождения памяти вызывается именно он, в противном случае – его глобальная версия. Параметр типа void* автоматически инициализируется значением адреса начала области памяти, в которой размещен массив.
Даже если в классе имеется оператор-член delete[](), программист может вызвать глобальный delete[](), воспользовавшись оператором разрешения глобальной области видимости:
::delete[] ps;
Добавление операторов new[]() или delete[]() в класс или удаление их оттуда не отражаются на пользовательском коде: вызовы как глобальных операторов, так и операторов-членов выглядят одинаково.
При создании массива сначала вызывается new[]() для выделения необходимой памяти, а затем каждый элемент инициализируется с помощью конструктора по умолчанию. Если у класса есть хотя бы один конструктор, но нет конструктора по умолчанию, то вызов оператора new[]() считается ошибкой. Не существует синтаксической конструкции для задания инициализаторов элементов массива или аргументов конструктора класса при создании массива подобным образом.
При уничтожении массива сначала вызывается деструктор класса для уничтожения элементов, а затем оператор delete[]() – для освобождения всей памяти. При этом важно использовать правильный синтаксис. Если в инструкции
delete ps;
ps указывает на массив объектов класса, то отсутствие квадратных скобок приведет к вызову деструктора лишь для первого элемента, хотя память будет освобождена полностью.
У оператора-члена delete[]() может быть не один, а два параметра, при этом второй должен иметь тип size_t:
class Screen {
public:
// заменяет
// void operator delete[]( void* );
void operator delete[]( void*, size_t );
};
Если второй параметр присутствует, то компилятор автоматически инициализирует его значением, равным объему отведенной под массив памяти в байтах.
Определение базового класса
Члены Query представляют:
множество операций, поддерживаемых всеми производными от него классами запросов. Сюда входят как виртуальные операции, переопределяемые в производных классах, так и невиртуальные, разделяемые всеми производными классами (мы приведем примеры тех и других);
множество данных-членов, общих для всех производных классов. Если вынести такие члены в абстрактный базовый класс Query, мы сможем обращаться к ним вне зависимости от того, с объектом какого производного класса мы работаем.
Если имеется запрос вида:
fiery || untamed
то двумя основными операциями для него будут: нахождение строк текста, удовлетворяющих условиям запроса, и представление найденных строк пользователю. Назовем эти операции соответственно eval() и display().
Алгоритм работы eval() свой для каждого производного класса, поэтому эту функцию следует объявить виртуальной в определении Query. Всякий производный класс должен предоставить собственную реализацию для нее. Сам же Query лишь включает ее в свой открытый интерфейс.
Алгоритм работы функции display(), выводящей найденные строки текста, не зависит от типа производного класса. Нам необходимо лишь иметь доступ к представлению самого текста и списку строк, удовлетворяющих запросу. Вместо того чтобы дублировать реализацию алгоритма и необходимые для него данные в каждом производном классе, определим единственный наследуемый экземпляр в Query.
Такое проектное решение позволит нам вызывать любую операцию, не зная фактического типа объекта, которым мы манипулируем:
void
doit( Query *pq )
{
// виртуальный вызов
pq->eval();
// статический вызов Query::display()
pq->display();
}
Как следует представить найденные строки текста? Каждому упомянутому в запросе слову будет соответствовать вектор позиций, построенный во время поиска. Позиция – это пара (строка, колонка), в которой каждый член – это значение типа short int. Отображение слов на векторы позиций, построенное функцией build_text_map(), содержит такие векторы для каждого встречающегося в тексте слова, распознанного нашей системой. Ключами для этого отображения служат значения типа string, представляющие слова. Например, для текста
Alice Emma has long flowing red hair. Her Daddy says
when the wind blows through her hair, it looks almost alive,
like a fiery bird in flight. A beautiful fiery bird, he tells her,
magical but untamed. "Daddy, shush, there is no such thing,"
she tells him, at the same time wanting him to tell her more.
Shyly, she asks, "I mean, Daddy, is there?"
приведена часть отображения для некоторых слов, встречающихся неоднократно (слово – это ключ отображения; пары значений в скобках – элементы вектора позиций; отметим, что нумерация строк и колонок начинается с нуля):
bird ((2,3),(2,9))
daddy ((0,8),(3,3),(5,5))
fiery ((2,2),(2,8))
hair ((0,6),(1,6))
her ((0,7),(1,5),(2,12),(4,11))
him ((4,2),(4,8))
she ((4,0),(5,1))
tell ((2,11),(4,1),(4,10))
Однако такой вектор – это еще ответ на запрос. К примеру, слово fiery представлено двумя позициями, причем обе находятся в одной и той же строке.
Нам нужно вычислить множество неповторяющихся строк, соответствующих вектору позиций. Для этого можно, например, создать вектор, в который помещаются все номера строк, представленные в векторе позиций, а затем передать его обобщенному алгоритму unique(), который удалит все дубликаты (см. алгоритм unique() в Приложении). Оставшиеся строки должны быть расположены в порядке возрастания номеров. Чтобы не оставалось никаких сомнений, к вектору строк можно применить обобщенный алгоритм sort().
Мы выбрали другой подход – построить множество (объект set) из номеров строк в векторе позиций. Такое множество содержит по одному экземпляру каждого элемента, причем хранит их в отсортированном виде. Нам потребуется функция для преобразования вектора позиций в множество неповторяющихся номеров строк:
set<short>* Query::_vec2set( const vector< location >* );
Объявим _vec2set() защищенной функцией-членом Query. Она не является открытой, поскольку не принадлежит к числу операций, которые могут вызывать пользователи данной иерархии. Но она и не закрыта, поскольку это вспомогательная функция, которая должна быть доступна производным классам. (Подчерк в имени функции призван обратить внимание на то, что это не часть открытого интерфейса иерархии Query.)
Например, вектор позиций для слова bird содержит два вхождения в одной и той же строке, поэтому его разрешающее множество будет состоять из одного элемента: (2). Вектор позиций для слова tell содержит три вхождения, из них два относятся к одной и той же строке; следовательно, в его разрешающем множестве будет два элемента: (2,4). Вот как выглядят результаты для всех представленных выше векторов позиций:
bird (2)
daddy (0,3,5)
fiery (2)
hair (0,1)
her (0,1,2,4)
him (4)
she (4,5)
tell (2,4)
Чтобы вычислить результат запроса NameQuery, достаточно получить вектор позиций для указанного слова, преобразовать его в множество неповторяющихся номеров строк и вывести соответствующие строки текста.
Ответом на NotQuery служит множество строк, в которых не встречается указанное слово. Так, результатом запроса
! daddy
служит множество (1,2,4). Для вычисления результата надо знать, сколько всего строк содержится в тексте. (Мы не сохраняли эту информацию, поскольку не были уверены, что она потребуется; к сожалению, недостаточно и этого.) Чтобы упростить обработку NotQuery, полезно сгенерировать множество всех номеров строк текста (0,1,2,3,4,5): теперь для получения результата достаточно с помощью алгоритма set_difference() вычислить разность двух множеств. (Ответом на показанный выше запрос будет множество (0,3,5).)
Результатом OrQuery является объединение номеров строк, где встречается левый или правый операнд. Например, если дан запрос:
fiery || her
то результирующим множеством будет (0,1,2,4), которое получается объединением множества (2) для слова fiery и множества (0,1,2,4) для слова her. Такое множество должно быть упорядочено по возрастанию номеров строк и не содержать дубликатов.
До сих пор нам удавалось вычислять результат запроса, работая только с множествами неповторяющихся номеров строк. Однако для обработки AndQuery надо принимать во внимание как номер строки, так и номер колонки в каждой паре. Так, указанные в запросе
her && hair
слова встречаются в четырех разных строках. Определенная нами семантика AndQuery говорит, что строка является подходящей, если содержит точную последовательность her hair. Вхождения слов в первую строку не удовлетворяют этому условию, хотя они стоят рядом:
Alice Emma has long flowing red hair. Her Daddy says
а вот во второй строке слова расположены так, как нужно:
when the wind blows through her hair, it looks almost alive,
Для оставшихся двух вхождений слова her слово hair не является соседним. Таким образом, ответом на запрос является вторая строка текста: (1).
Если бы не операция AndQuery, нам не пришлось бы вычислять вектор позиций для каждой операции. Но, поскольку операндом AndQuery может быть результат любого запроса, то для каждого приходится вычислять и сохранять не только множество неповторяющихся строк, но и пары (строка, колонка). Рассмотрим следующие запросы:
fiery && ( hair || bird || potato )
fiery && ( ! burr )
NotQuery может быть операндом AndQuery, следовательно, мы должны создать не просто вектор, содержащий по одному элементу для каждой подходящей строки, но и вектор, в котором хранятся позиции. (Мы еще вернемся к этому при рассмотрении функции eval() для класса NotQuery в разделе 17.5.)
Таким образом, идентифицирован еще один необходимый член – вектор позиций, ассоциированный с вычислением каждой операции. У нас есть выбор: объявить его членом каждого производного класса или членом абстрактного базового класса Query, наследуемым всеми производными. Объем памяти для хранения этого члена в обоих случаях одинаков. Мы поместим его в базовый класс, локализовав поддержку инициализации и доступа к члену.
Решение о том, представлять ли множество неповторяющихся номеров строк (мы называем его разрешающим множеством) в виде члена класса или каждый раз вычислять его, принимает разработчик. Мы предпочли вычислять его по мере необходимости, а затем сохранять адрес для последующего доступа, объявляя этот адрес членом абстрактного базового класса Query.
Для вывода найденных строк нам необходимо как разрешающее множество, так и фактический текст, из которого взяты строки. Причем вектор позиций у каждой операции должен быть свой, а экземпляр текста нужен только один. Поэтому мы определим его статическим членом класса Query. (Реализация функции display() опирается только на эти два члена.)
Вот результат первой попытки создать абстрактный базовый класс Query (конструкторы, деструктор и копирующий оператор присваивания еще не объявлены: этим мы займемся в разделах 17.4 и 17.6):
#include <vector>
#include <set>
#include <string>
#include <utility>
typedef pair< short, short > location;
class Query {
public:
// конструкторы и деструктор обсуждаются в разделе 17.4
// копирующий конструктор и копирующий оператор присваивания
// обсуждаются в разделе 17.6
// операции для поддержки открытого интерфейса
virtual void eval() = 0;
virtual void display () const;
// функции доступа для чтения
const set<short> *solution() const;
const vector<location> *locations() const { return &_loc; }
static const vector<string> *text_file() {return _text_file;}
protected:
set<short>* _vec2set( const vector<location>* );
static vector<string> *_text_file;
set<short> *_solution;
vector<location> _loc;
};
inline const set<short>
Query::
solution()
{
return _solution
? _solution
: _solution = _vec2set( &_loc );
}
Странный синтаксис
virtual void eval() = 0;
говорит о том, что для виртуальной функции eval() в абстрактном базовом классе Query нет определения: это чисто виртуальная функция, “удерживающая место” в открытом интерфейсе иерархии классов и не предназначенная для непосредственного вызова из программы. Вместо нее каждый производный класс должен предоставить настоящую реализацию. (Подробно виртуальные функции будут рассматриваться в разделе 17.5.)
Определение члена пространства имен
Мы видели, что определение члена пространства имен может появиться внутри определения самого пространства. Например, класс matrix и константа pi появляются внутри вложенного пространства имен MatrixLib, а определения функций operator+() и inverse() приводятся где-то в другом месте текста программы:
// ---- primer.h ----
namespace cplusplus_primer {
// первое вложенное пространство имен:
// матричная часть библиотеки
namespace MatrixLib {
class matrix { /* ... */ };
const double pi = 3.1416;
matrix operators+ ( const matrix &ml, const matrix &m2 );
void inverse( matrix & );
// ...
}
}
Член пространства имен можно определить и вне соответствующего пространства. В таком случае имя члена должно быть квалифицировано именами пространств, к которым он принадлежит. Например, если определение функции operator+() помещено в глобальную область видимости, то оно должно выглядеть следующим образом:
// ---- primer.C ----
#include "primer.h"
// определение в глобальной области видимости
cplusplus_primer::MatrixLib::matrix
cplusplus_primer::MatrixLib::operator+
( const matrix& ml, const matrix &m2 )
{ /* ... */ }
Имя operator+() квалифицировано в данном случае именами пространств cplusplus_primer и MatrixLib. Однако обратите внимание на тип matrix в списке параметров operator+(): употреблено неквалифицированное имя. Как такое может быть?
В определении функции operator+() можно использовать неквалифицированные имена для членов своего пространства, поскольку определение принадлежит к его области видимости. При разрешении имен внутри функции operator+() используется MatrixLib. Заметим, однако, что в типе возвращаемого значения все же нужно указывать квалифицированное имя, поскольку он расположен вне области видимости, заданной определением функции:
cplusplus_primer::MatrixLib::operator+
В определении operator+() неквалифицированные имена могут встречаться в любом объявлении или выражении внутри списка параметров или тела функции. Например, локальное объявление внутри operator+() способно создать объект класса matrix:
// ---- primer.C ----
#include "primer.h"
cplusplus_primer::MatrixLib::matrix
cplusplus_primer::MatrixLib::operator+
( const matrix &ml, const matrix &m2 )
{
// объявление локальной переменной типа
// cplusplus_primer::MatrixLib::matrix
matrix res;
// вычислим сумму двух объектов matrix
return res;
}
Хотя члены могут быть определены вне своего пространства имен, такие определения допустимы не в любом месте. Их разрешается помещать только в пространства, объемлющие данное. Например, определение operator+() может появиться в глобальной области видимости, в пространстве имен cplusplus_primer и в пространстве MatrixLib. В последнем случае это выглядит так:
// ---- primer.C --
#include "primer.h"
namespace cplusplus_primer {
MatrixLib::matrix MatrixLib::operator+
( const matrix &ml, const matrix &m2 ) { /* ... */ }
}
Член может определяться вне своего пространства только при условии, что ранее он был объявлен внутри. Последнее приведенное определение operator+() было бы ошибочным, если бы ему не предшествовало объявление в файле primer.h:
namespace cplusplus_primer {
namespace MatrixLib {
class matrix { /*...*/ };
// следующее объявление не может быть пропущено
matrix operator+ ( const matrix &ml, const matrix &m2 );
// ...
}
}
Определение иерархии классов
В этой главе мы построим иерархию классов для представления запроса пользователя. Сначала реализуем каждую операцию в виде отдельного класса:
NameQuery // Shakespeare
NotQuery // ! Shakespeare
OrQuery // Shakespeare || Marlowe
AndQuery // William && Shakespeare
В каждом классе определим функцию-член eval(), которая выполняет соответствующую операцию. К примеру, для NameQuery она возвращает вектор позиций, содержащий координаты (номера строки и колонки) начала каждого вхождения слова (см. раздел 6.8); для OrQuery строит объединение векторов позиций обоих своих операндов и т.д.
Таким образом, запрос
untamed || fiery
состоит из объекта класса OrQuery, который содержит два объекта NameQuery в качестве операндов. Для простых запросов этого достаточно, но при обработке составных запросов типа
Alice || Emma && Weeks
возникает проблема. Данный запрос состоит из двух подзапросов: объекта OrQuery, содержащего объекты NameQuery для представления слов Alice и Emma, и объекта AndQuery. Правым операндом AndQuery является объект NameQuery для слова Weeks.
AndQuery
OrQuery
NameQuery ("Alice")
NameQuery ("Emma")
NameQuery ("Weeks")
Но левый операнд– это объект OrQuery, предшествующий оператору &&. На его месте мог бы быть объект NotQuery или другой объект AndQuery. Как же следует представить операнд, если он может принадлежать к типу любого из четырех классов? Эта проблема имеет две стороны:
необходимо уметь объявлять тип операнда в классах OrQuery, AndQuery и NotQuery так, чтобы с его помощью можно было представить тип любого из четырех классов запросов;
какое бы решение мы ни выбрали в предыдущем случае, мы должны иметь возможность вызывать соответствующий классу каждого операнда вариант функции-члена eval().
Решение, не согласующееся с объектной ориентированностью, состоит в том, чтобы определить тип операнда как объединение и включить дискриминант, показывающий текущий тип операнда:
// не объектно-ориентированное решение
union op_type {
// объединение не может содержать объекты классов с
// ассоциированными конструкторами
NotQuery *nq;
OrQuery *oq;
AndQuery *aq;
string *word;
};
enum opTypes {
Not_query=1, O_query, And_query, Name_query
};
class AndQuery {
public:
// ...
private:
/*
* opTypes хранит информацию о фактических типах операндов запроса
* op_type - это сами операнды
*/
op_type _lop, _rop;
opTypes _lop_type, _rop_type;
};
Хранить указатели на объекты можно и с помощью типа void*:
class AndQuery {
public:
// ...
private:
void * _lop, _rop;
opTypes _lop_type, _rop_type;
};
Нам все равно нужен дискриминант, поскольку напрямую использовать объект, адресуемый указателем типа void*, нельзя, равно как невозможно определить тип такого объекта по указателю. (Мы не рекомендуем применять описанное решение в C++, хотя в языке C это весьма распространенный подход.)
Основной недостаток рассмотренных решений состоит в том, что ответственность за определение типа возлагается на программиста. Например, в случае решения, основанного на void*-указателях, операцию eval() для объекта AndQuery можно реализовать так:
void
AndQuery::
eval()
{
// не объектно-ориентированный подход
// ответственность за разрешение типа ложится на программиста
// определить фактический тип левого операнда
switch( _lop_type ) {
case And_query:
AndQuery *paq = static_cast<AndQuery*>(_lop);
paq->eval();
break;
case Or_query:
OrQuery *pqq = static_cast<OrQuery*>(_lop);
poq->eval();
break;
case Not_query:
NotQuery *pnotq = static_cast<NotQuery*>(_lop);
pnotq->eval();
break;
case Name_query:
AndQuery *pnmq = static_cast<NameQuery*>(_lop);
pnmq->eval();
break;
}
// то же для правого операнда
}
В результате явного управления разрешением типов увеличивается размер и сложность кода и добавление нового типа или исключение существующего при сохранении работоспособности программы затрудняется.
Объектно-ориентированное программирование предлагает альтернативное решение, в котором работа по разрешению типов перекладывается с программиста на компилятор. Например, так выглядит код операции eval() для класса AndQuery в случае применения объектно-ориентированного подхода (eval() объявлена виртуальной):
// объектно-ориентированное решение
// ответственность за разрешение типов перекладывается на компилятор
// примечание: теперь _lop и _rop - объекты типа класса
// их определения будут приведены ниже
void
AndQuery::
eval()
{
_lop->eval();
_rop->eval();
}
Если потребуется добавить или исключить какие-либо типы, эту часть программы не придется ни переписывать, ни перекомпилировать.
Определение класса
Определение класса состоит из двух частей: заголовка, включающего ключевое слово class, за которым следует имя класса, и тела, заключенного в фигурные скобки. После такого определения должны стоять точка с запятой или список объявлений:
class Screen { /* ... */ };
class Screen { /* ... */ } myScreen, yourScreen;
Внутри тела объявляются данные-члены и функции-члены и указываются уровни доступа к ним. Таким образом, тело класса определяет список его членов.
Каждое определение вводит новый тип данных. Даже если два класса имеют одинаковые списки членов, они все равно считаются разными типами:
class First {
int memi;
double memd;
};
class Second {
int memi;
double memd;
};
class First obj1;
Second obj2 = obj1; // ошибка: obj1 и obj2 имеют разные типы
Тело класса определяет отдельную область видимости. Объявление членов внутри тела помещает их имена в область видимости класса. Наличие в двух разных классах членов с одинаковыми именами – не ошибка, эти имена относятся к разным объектам. (Подробнее об областях видимости классов мы поговорим в разделе 13.9.)
После того как тип класса определен, на него можно ссылаться двумя способами:
написать ключевое слово class, а после него – имя класса. В предыдущем примере объект obj1 класса First объявлен именно таким образом;
указать только имя класса. Так объявлен объект obj2 класса Second из приведенного примера.
Оба способа сослаться на тип класса эквивалентны. Первый заимствован из языка C и остается корректным методом задания типа класса; второй способ введен в C++ для упрощения объявлений.
Определение класса UserQuery
Объект класса UserQuery можно инициализировать указателем на вектор строк, представляющий запрос пользователя, или передать ему адрес этого вектора позже, с помощью функции-члена query(). Это позволяет использовать один объект для нескольких запросов. Фактическое построение иерархии классов Query выполняется функцией eval_query():
// определить объект, не имея запроса пользователя
UserQuery user_query;
string text;
vector<string> query_text;
// обработать запросы пользователя
do {
while( cin >> text )
query_text.push_back( text );
// передать запрос объекту UserQuery
user_query.query( &query_text );
// вычислить результат запроса и вернуть
// корень иерархии Query*
Query *query = user_query.eval_query();
}
while ( /* пользователь продолжает формулировать запросы */ );
Вот определение нашего класса UserQuery:
#ifndef USER_QUERY_H
#define USER_QUERY_H
#include <string>
#include <vector>
#include <map>
#include <stack>
typedef pair<short,short> location;
typedef vector<location,allocator> loc;
#include "Query.h"
class UserQuery {
public:
UserQuery( vector< string,allocator > *pquery = 0 )
: _query( pquery ), _eval( 0 ), _paren( 0 ) {}
Query *eval_query(); // строит иерархию
void query( vector< string,allocator > *pq );
void displayQuery();
static void word_map( map<string,loc*,less<string>,allocator> *pwm ) {
if ( !_word_map ) _word_map = pwm;
}
private:
enum QueryType { WORD = 1, AND, OR, NOT, RPAREN, LPAREN };
QueryType evalQueryString( const string &query );
void evalWord( const string &query );
void evalAnd();
void evalOr();
void evalNot();
void evalRParen();
bool integrity_check();
int _paren;
Query *_eval;
vector<string> *_query;
stack<Query*, vector<Query*> > _query_stack;
stack<Query*, vector<Query*> > _current_op;
static short _lparenOn, _rparenOn;
static map<string,loc*,less<string>,allocator> *_word_map;
};
#endif
Обратите внимание, что два объявленных нами стека содержат указатели на объекты типа Query, а не сами объекты. Хотя правильное поведение обеспечивается обеими реализациями, хранение объектов значительно менее эффективно, поскольку каждый объект (и его операнды) должен быть почленно скопирован в стек (напомним, что операнды копируются виртуальной функцией clone()) только для того, чтобы вскоре быть уничтоженным. Если мы не собираемся модифицировать объекты, помещаемые в контейнер, то хранение указателей на них намного эффективнее.
Ниже показаны реализации различных встроенных операций eval. Операции evalAnd() и evalOr() выполняют следующие шаги. Сначала объект извлекается из стека _query_stack (напомним, что для класса stack, определенного в стандартной библиотеке, это требует двух операций: top() для получения элемента и pop() для удаления его из стека). Затем из хипа выделяется память для объекта класса AndQuery или OrQuery, и указатель на него передается объекту, извлеченному из стека. Каждая операция передает объекту AndQuery или OrQuery счетчики левых или правых скобок, необходимые ему для вывода своего содержимого. И наконец неполный оператор помещается в стек _current_op:
inline void
UserQuery::
evalAnd()
{
Query *pop = _query_stack.top(); _query_stack.pop();
AndQuery *pq = new AndQuery( pop );
if ( _lparenOn )
{ pq->lparen( _lparenOn ); _lparenOn = 0; }
if ( _rparenOn )
{ pq->rparen( _rparenOn ); _rparenOn = 0; }
_current_op.push( pq );
}
inline void
UserQuery::
evalOr()
{
Query *pop = _query_stack.top(); _query_stack.pop();
OrQuery *pq = new OrQuery( pop );
if ( _lparenOn )
{ pq->lparen( _lparenOn ); _lparenOn = 0; }
if ( _rparenOn )
{ pq->rparen( _rparenOn ); _rparenOn = 0; }
_current_op.push( pq );
}
Операция evalNot() работает следующим образом. В хипе создается новый объект класса NotQuery, которому передаются счетчики левых и правых скобок для правильного отображения содержимого. Затем неполный оператор помещается в стек _current_op:
inline void
UserQuery::
evalNot()
{
NotQuery *pq = new NotQuery;
if ( _lparenOn )
{ pq->lparen( _lparenOn ); _lparenOn = 0; }
if ( _rparenOn )
{ pq->rparen( _rparenOn ); _rparenOn = 0; }
_current_op.push( pq );
}
При обнаружении закрывающей скобки вызывается операция evalRParen(). Если число активных левых скобок больше числа элементов в стеке _current_op, то ничего не происходит. В противном случае выполняются следующие действия. Из стека _query_stack извлекается текущий еще не присоединенный к оператору операнд, а из стека _current_op – текущий неполный оператор. Вызывается виртуальная функция add_op() класса Query, которая их объединяет. И наконец полный оператор помещается в стек _query_stack:
inline void
UserQuery::
evalRParen()
{
if ( _paren < _current_op.size() )
{
Query *poperand = _query_stack.top();
_query_stack.pop();
Query *pop = _current_op.top();
_current_op.pop();
pop->add_op( poperand );
_query_stack.push( pop );
}
}
Операция evalWord() выполняет следующие действия. Она ищет указанное слово в отображении _word_map взятых из файла слов на векторы позиций. Если слово найдено, берется его вектор позиций и в хипе посредством конструктора с двумя параметрами создается новый объект NameQuery. В противном случае объект порождается с помощью конструктора с одним параметром. Если число элементов в стеке _current_op меньше либо равно числу встреченных ранее скобок, то нет неполного оператора, ожидающего операнда типа NameQuery, поэтому новый объект помещается в стек _query_stack. Иначе из стека _current_op извлекается неполный оператор, к которому с помощью виртуальной функции add_op() присоединяется операнд NameQuery, после чего ставший полным оператор помещается в стек _query_stack:
inline void
UserQuery::
evalWord( const string &query )
{
NameQuery *pq;
loc *ploc;
if ( ! _word_map->count( query ))
pq = new NameQuery( query );
else {
ploc = ( *_word_map )[ query ];
pq = new NameQuery( query, *ploc );
}
if ( _current_op.size() <= _paren )
_query_stack.push( pq );
else {
Query *pop = _current_op.top();
_current_op.pop();
pop->add_op( pq );
_query_stack.push( pop );
}
}
Упражнение 17.21
Напишите деструктор, копирующий конструктор и копирующий оператор присваивания для класса UserQuery.
Упражнение 17.22
Напишите функции print() для класса UserQuery. Обоснуйте свой выбор того, что она выводит.
Определение объекта
В самом простом случае оператор определения объекта состоит из спецификатора типа и имени объекта и заканчивается точкой с запятой. Например:
double salary;
double wage;
int month;
int day;
int year;
unsigned long distance;
В одном операторе можно определить несколько объектов одного типа. В этом случае их имена перечисляются через запятую:
double salary, wage;
int month,
day, year;
unsigned long distance;
Простое определение переменной не задает ее начального значения. Если объект определен как глобальный, спецификация С++ гарантирует, что он будет инициализирован нулевым значением. Если же переменная локальная либо динамически размещаемая (с помощью оператора new), ее начальное значение не определено, то есть она может содержать некоторое случайное значение.
Использование подобных переменных– очень распространенная ошибка, которую к тому же трудно обнаружить. Рекомендуется явно указывать начальное значение объекта, по крайней мере в тех случаях, когда неизвестно, может ли объект инициализировать сам себя. Механизм классов вводит понятие конструктора по умолчанию, который служит для присвоения значений по умолчанию. (Мы уже сказали об этом в разделе 2.3. Разговор о конструкторах по умолчанию будет продолжен немного позже, в разделах 3.11 и 3.15, где мы будем разбирать классы string и complex из стандартной библиотеки.)
int main() {
// неинициализированный локальный объект
int ival;
// объект типа string инициализирован
// конструктором по умолчанию
string project;
// ...
}
Начальное значение может быть задано прямо в операторе определения переменной. В С++ допустимы две формы инициализации переменной – явная, с использованием оператора присваивания:
int ival = 1024;
string project = "Fantasia 2000";
и неявная, с заданием начального значения в скобках:
int ival( 1024 );
string project( "Fantasia 2000" );
Оба варианта эквивалентны и задают начальные значения для целой переменной ival как 1024 и для строки project как "Fantasia 2000".
Явную инициализацию можно применять и при определении переменных списком:
double salary = 9999.99, wage = salary + 0.01;
int month = 08;
day = 07, year = 1955;
Переменная становится видимой (и допустимой в программе) сразу после ее определения, поэтому мы могли проинициализировать переменную wage суммой только что определенной переменной salary с некоторой константой. Таким образом, определение:
// корректно, но бессмысленно
int bizarre = bizarre;
является синтаксически допустимым, хотя и бессмысленным.
Встроенные типы данных имеют специальный синтаксис для задания нулевого значения:
// ival получает значение 0, а dval - 0.0
int ival = int();
double dval = double();
В следующем определении:
// int() применяется к каждому из 10 элементов
vector< int > ivec( 10 );
к каждому из десяти элементов вектора применяется инициализация с помощью int(). (Мы уже говорили о классе vector в разделе 2.8. Более подробно об этом см. в разделе 3.10 и главе 6.)
Переменная может быть инициализирована выражением любой сложности, включая вызовы функций. Например:
#include <cmath>
#include <string>
double price = 109.99, discount = 0.16;
double sale_price( price * discount );
string pet( "wrinkles" );
extern int get_value();
int val = get_value();
unsigned abs_val = abs( val );
abs() – стандартная функция, возвращающая абсолютное значение параметра. get_value() – некоторая пользовательская функция, возвращающая целое значение.
Упражнение 3.3
Какие из приведенных ниже определений переменных содержат синтаксические ошибки?
(a) int car = 1024, auto = 2048;
(b) int ival = ival;
(c) int ival( int() );
(d) double salary = wage = 9999.99;
(e) cin >> int input_value;
Упражнение 3.4
Объясните разницу между l-значением и r-значением. Приведите примеры.
Упражнение 3.5
Найдите отличия в использовании переменных name и student в первой и второй строчках каждого примера:
(a) extern string name;
string name( "exercise 3.5a" );
(b) extern vector<string> students;
vector<string> students;
Упражнение 3.6
Какие имена объектов недопустимы в С++? Измените их так, чтобы они стали синтаксически правильными:
(a) int double = 3.14159; (b) vector< int > _;
(c) string namespase; (d) string catch-22;
(e) char 1_or_2 = '1'; (f) float Float = 3.14f;
Упражнение 3.7
В чем разница между следующими глобальными и локальными определениями переменных?
string global_class;
int global_int;
int main() {
int local_int;
string local_class;
// ...
}
Определение объекта map и заполнение его элементами
Чтобы определить объект класса map, мы должны указать, как минимум, типы ключа и значения. Например:
map<string,int> word_count;
Здесь задается объект word_count типа map, для которого ключом служит объект типа string, а ассоциированным с ним значением – объект типа int. Аналогично
class employee;
map<int,employee*> personnel;
определяет personnel как отображение ключа типа int (уникальный номер служащего) на указатель, адресующий объект класса employee.
Для нашей поисковой системы полезно такое отображение:
typedef pair<short,short> location;
typedef vector<location> loc;
map<string,loc*> text_map;
Поскольку имевшийся в нашем распоряжении компилятор не поддерживал аргументы по умолчанию для параметров шаблона, нам пришлось написать более развернутое определение:
map<string,loc*, // ключ, значение
less<string>, // оператор сравнения
allocator> // распределитель памяти по умолчанию
text_map;
По умолчанию сортировка ассоциативных контейнеров производится с помощью операции “меньше”. Однако можно указать и другой оператор сравнения (см. раздел 12.3 об объектах-функциях).
После того как отображение определено, необходимо заполнить его парами ключ/значение. Интуитивно хочется написать примерно так:
#include <map>
#include <string>
map<string,int> word_count;
word_count[ string("Anna") ] = 1;
word_count[ string("Danny") ] = 1;
word_count[ string("Beth") ] = 1;
// и так далее ...
Когда мы пишем:
word_count[ string("Anna") ] = 1;
на самом деле происходит следующее:
1. Безымянный временный объект типа string инициализируется значением "Anna" и передается оператору взятия индекса, определенному в классе map.
2. Производится поиск элемента с ключом "Anna" в массиве word_count. Такого элемента нет.
3. В word_count вставляется новая пара ключ/значение. Ключом является, естественно, строка "Anna". Значением – 0, а не 1.
4. После этого значению присваивается величина 1.
Если элемент отображения вставляется в отображение с помощью операции взятия индекса, то значением этого элемента становится значение по умолчанию для его типа данных. Для встроенных арифметических типов – 0.
Следовательно, если инициализация отображения производится оператором взятия индекса, то каждый элемент сначала получает значение по умолчанию, а затем ему явно присваивается нужное значение. Если элементы являются объектами класса, у которого инициализация по умолчанию и присваивание значения требуют больших затрат времени, программа будет работать правильно, но недостаточно эффективно.
Для вставки одного элемента предпочтительнее использовать следующий метод:
// предпочтительный метод вставки одного элемента
word_count.insert(
map<string,i nt>::
value_type( string("Anna"), 1 )
);
В контейнере map определен тип value_type для представления хранимых в нем пар ключ/значение. Строки
map< string,int >::
value_type( string("Anna"), 1 )
создают объект pair, который затем непосредственно вставляется в map. Для удобства чтения можно использовать typedef:
typedef map<string,int>::value_type valType;
Теперь операция вставки выглядит проще:
word_count.insert( valType( string("Anna"), 1 ));
Чтобы вставить элементы из некоторого диапазона, можно использовать метод insert(), принимающий в качестве параметров два итератора. Например:
map< string, int > word_count;
// ... заполнить
map< string,int > word_count_two;
// скопируем все пары ключ/значение
word_count_two.insert(word_count.begin(),word_count.end());
Мы могли бы сделать то же самое, просто проинициализировав одно отображение другим:
// инициализируем копией всех пар ключ/значение
map< string, int > word_count_two( word_count );
Посмотрим, как можно построить отображение для хранения нашего текста. Функция separate_words(), описанная в разделе 6.8, создает два объекта: вектор строк, хранящий все слова текста, и вектор позиций, хранящий пары (номер строки, номер колонки) для каждого слова. Таким образом, первый объект дает нам множество значений ключей нашего отображения, а второй – множество ассоциированных с ними значений.
separate_words() возвращает эти два вектора как объект типа pair, содержащий указатели на них. Сделаем эту пару аргументом функции build_word_map(), в результате которой будет получено соответствие между словами и позициями:
// typedef для удобства чтения
typedef pair< short,short > location;
typedef vector< location > loc;
typedef vector< string > text;
typedef pair< text*,loc* > text_loc;
extern map< string, loc* >*
build_word_map( const text_loc *text_locations );
Сначала выделим память для пустого объекта map и получим из аргумента-пары указатели на векторы:
map<string,loc*> *word_map = new map< string, loc* >;
vector<string> *text_words = text_locations->first;
vector<location> *text_locs = text_locations->second;
Теперь нам надо синхронно обойти оба вектора, учитывая два случая:
слово встретилось впервые. Нужно поместить в map новую пару ключ/значение;
слово встречается повторно. Нам нужно обновить вектор позиций, добавив дополнительную пару (номер строки, номер колонки).
Вот текст функции:
register int elem_cnt = text_words->size();
for ( int ix=0; ix < elem_cnt; ++ix )
{
string textword = ( *text_words )[ ix ];
// игнорируем слова короче трех букв
// или присутствующие в списке стоп-слов
if ( textword.size() < 3 ||
exclusion_set.count( textword ))
continue;
// определяем, занесено ли слово в отображение
// если count() возвращает 0 - нет: добавим его
if ( ! word_map->count((*text_words)[-ix] ))
{
loc *ploc = new vector<location>;
ploc->push_back( (*text_locs) [ix] );
word_map->insert(value_type((*text_words)[ix],ploc));
}
else
// добавим дополнительные координаты
(*word_map)[(*text_words)[ix]]->
push_back((*text_locs)[ix]);
}
Синтаксически сложное выражение
(*word_map)[(*text_words)[ix]]->
push_back((*text_locs)[ix]);
будет проще понять, если мы разложим его на составляющие:
// возьмем слово, которое надо обновить
string word = (*text_words) [ix];
// возьмем значение из вектора позиций
vector<location> *ploc = (*word_map) [ word ];
// возьмем позицию - пару координат
loc = (*text_locs)[ix];
// вставим новую позицию
ploc->push_back(loc);
Выражение все еще остается сложным, так как наши векторы представлены указателями. Поэтому вместо употребления оператора взятия индекса:
string word = text_words[ix]; // ошибка
мы вынуждены сначала разыменовать указатель на вектор:
string word = (*text_words) [ix]; // правильно
В конце концов build_word_map() возвращает построенное отображение:
return word_map;
Вот как выглядит вызов этой функции из main():
int main()
{
// считываем файл и выделяем слова
vector<string, allocator> *text_file = retrieve_text();
text_loc *text_locations = separate_words( text_file );
// обработаем слова
// ...
// построим отображение слов на векторы позиций
map<string,lос*,less<string>,allocator>
*text_map = build_word_map( text_locatons );
// ...
}
Определение объекта set и заполнение его элементами
Перед использованием класса set необходимо включить соответствующий заголовочный файл:
#include <set>
Вот определение нашего множества стоп-слов:
set<string> exclusion_set;
Отдельные элементы могут добавляться туда с помощью операции insert(). Например:
exclusion_set.insert( "the" );
exclusion_set.insert( "and" );
Передавая insert() пару итераторов, можно добавить целый диапазон элементов. Скажем, наша поисковая система позволяет указать файл со стоп-словами. Если такой файл не задан, берется некоторый набор слов по умолчанию:
typedef set< string >::difference_type diff_type;
set< string > exclusion_set;
ifstream infile( "exclusion_set" );
if ( ! infile )
{
static string default_excluded_words[25] = {
"the","and","but","that","then","are","been",
"can"."can't","cannot","could","did","for",
"had","have","him","his","her","its","into",
"were","which","when","with","would"
};
cerr << "предупреждение! невозможно открыть файл стоп-слов! -- "
<< "используется стандартный набор слов \n";
copy( default_excluded_words, default_excluded_words+25,
inserter( exclusion_set, exclusion_set.begin() ));
}
else {
istream_iterator<string,diff_type> input_set(infile),eos;
copy( input_set, eos, inserter( exclusion_set,
exclusion_set.begin() ));
}
В этом фрагменте кода встречаются два элемента, которые мы до сих пор не рассматривали: тип difference_type и класс inserter. difference_type – это тип результата вычитания двух итераторов для нашего множества строк. Он передается в качестве одного из параметров шаблона istream_iterator.
copy() –один из обобщенных алгоритмов. (Мы рассмотрим их в главе 12 и в Приложении.) Первые два параметра – пара итераторов или указателей – задают диапазон. Третий параметр является либо итератором, либо указателем на начало контейнера, в который элементы копируются.
Проблема с этой функцией вызвана ограничением, вытекающим из ее реализации: количество копируемых элементов не может превосходить числа элементов в контейнере-адресате. Дело в том, что copy() не вставляет элементы, она только присваивает каждому элементу новое значение. Однако ассоциативные контейнеры не позволяют явно задать размер. Чтобы скопировать элементы в наше множество, мы должны заставить copy() вставлять элементы. Именно для этого служит класс inserter (детально он рассматривается в разделе 12.4).
Определение производных классов
Каждый производный класс наследует данные и функции-члены своего базового класса, и программировать приходится лишь те аспекты, которые изменяют или расширяют его поведение. К примеру, в классе NameQuery необходимо определить реализацию eval(). Кроме того, нужна поддержка для хранения слова-операнда, представленного объектом класса типа string.
Наконец, для получения ассоциированного вектора позиций должно быть доступно отображение слов на векторы. Поскольку один такой объект разделяется всеми объектами класса NameQuery, мы объявляем его статическим членом. Первая попытка определения NameQuery (рассмотрение конструкторов, деструктора и копирующего оператора присваивания мы снова отложим) выглядит так:
typedef vector<location> loc;
class NameQuery : public Query {
public:
// ...
// переопределяет виртуальную функцию Query::eval()2
virtual void eval();
// функция чтения
string name() const { return _name; }
static const map<string,loc*> *word_map() { return _word_map; }
protected:
string _name;
static map<string,loc*> *_word_map;
};
Класс NotQuery в дополнение к предоставлению реализации виртуальной функции eval() должен обеспечить поддержку своего единственного операнда. Поскольку им может быть объект любого из производных классов, определим его как указатель на тип Query. Результат запроса NotQuery, напомним, обязан содержать не только строки текста, где нет указанного слова, но также и номера колонок внутри каждой строки. Например, если есть запрос:
! daddy
то операнд запроса NotQuery включает следующий вектор позиций:
daddy ((0,8),(3,3),(5,5))
Вектор позиций, возвращаемый в ответ на исходный запрос, должен включать все номера колонок в строках (1,2,4). Кроме того, он должен включать все номера колонок в строке (0), кроме колонки (8), все номера колонок в строке (3), кроме колонки (3), и все номера колонок в строке (5), кроме колонки (5).
Простейший способ вычислить все это – создать единственный разделяемый всеми объектами вектор позиций, который содержит пары (строка, колонка) для каждого слова в тексте (полную реализацию мы рассмотрим в разделе 17.5, когда будем обсуждать функцию eval() класса NotQuery). Так или иначе, этот член мы объявим статическим для NotQuery.
Вот определение класса NotQuery ( и снова рассмотрение конструкторов, деструктора и копирующего оператора присваивания отложено):
class NotQuery : public Query {
public:
// ...
// альтернативный синтаксис: явно употреблено ключевое слово virtual
// переопределение Query::eval()
virtual void eval();
// функция доступа для чтения
const Query *op() const { return _op; }
static const vector< location > * all_locs() {
return _all_locs; }
protected:
Query *_op;
static const vector< location > *_all_locs;
};
Классы AndQuery и OrQuery представляют бинарные операции, у которых есть левый и правый операнды. Оба операнда могут быть объектами любого из производных классов, поэтому мы определим соответствующие члены как указатели на тип Query. Кроме того, в каждом классе нужно переопределить виртуальную функцию eval(). Вот начальное определение OrQuery:
class OrQuery : public Query {
public:
// ...
virtual void eval();
const Query *rop() const { return _rop; }
const Query *lop() const { return _lop; }
protected:
Query *_lop;
Query *_rop;
};
Любой объект AndQuery должен иметь доступ к числу слов в каждой строке. В противном случае при обработке запроса AndQuery мы не сможем найти соседние слова, расположенные в двух смежных строках. Например, если есть запрос:
tell && her && magical
то нужная последовательность находится в третьей и четвертой строках:
like a fiery bird in flight. A beautiful fiery bird, he tells her,
magical but untamed. "Daddy, shush, there is no such thing,"
Векторы позиций, ассоциированные с каждым из трех слов, следующие:
her ((0,7),(1,5),(2,12),(4,11))
magical ((3,0))
tell ((2,11),(4,1),(4,10))
Если функция eval() класса AndQuery “не знает”, сколько слов содержится в строке (2), то она не сможет определить, что слова magical и her соседствуют. Мы создадим единственный экземпляр вектора, разделяемый всеми объектами класса, и объявим его статическим членом. (Реализацию eval() мы детально рассмотрим в разделе 17.5.) Итак, определим AndQuery:
class AndQuery : public Query {
public:
// конструкторы обсуждаются в разделе 17.4
virtual void eval();
const Query *rop() const { return _rop; }
const Query *lop() const { return _lop; }
static void max_col( const vector< int > *pcol )
{ if ( !_max_col ) _max_col = pcol; }
protected:
Query *_lop;
Query *_rop;
static const vector< int > *_max_col;
};
Определение шаблона функции
Иногда может показаться, что сильно типизированный язык создает препятствия для реализации совсем простых функций. Например, хотя следующий алгоритм функции min() тривиален, сильная типизация требует, чтобы его разновидности были реализованы для всех типов, которые мы собираемся сравнивать:
int min( int a, int b ) {
return a < b ? a : b;
}
double min( double a, double b ) {
return a < b ? a : b;
}
Заманчивую альтернативу явному определению каждого экземпляра функции min() представляет использование макросов, расширяемых препроцессором:
#define min(a, b) ((a) < (b) ? (a) : (b))
Но этот подход таит в себе потенциальную опасность. Определенный выше макрос правильно работает при простых обращениях к min(), например:
min( 10, 20 );
min( 10.0, 20.0 );
но может преподнести сюрпризы в более сложных случаях: такой механизм ведет себя не как вызов функции, он лишь выполняет текстовую подстановку аргументов. В результате значения обоих аргументов оцениваются дважды: один раз при сравнении a и b, а второй – при вычислении возвращаемого макросом результата:
#include <iostream>
#define min(a,b) ((a) < (b) ? (a) : (b))
const int size = 10;
int ia[size];
int main() {
int elem_cnt = 0;
int *p = &ia[0];
// подсчитать число элементов массива
while ( min(p++,&ia[size]) != &ia[size] )
++elem_cnt;
cout << "elem_cnt : " << elem_cnt
<< "\texpecting: " << size << endl;
return 0;
}
На первый взгляд, эта программа подсчитывает количество элементов в массиве ia целых чисел. Но в этом случае макрос min() расширяется неверно, поскольку операция постинкремента применяется к аргументу-указателю дважды при каждой подстановке. В результате программа печатает строку, свидетельствующую о неправильных вычислениях:
elem_cnt : 5 expecting: 10
Шаблоны функций предоставляют в наше распоряжение механизм, с помощью которого можно сохранить семантику определений и вызовов функций (инкапсуляция фрагмента кода в одном месте программы и гарантированно однократное вычисление аргументов), не принося в жертву сильную типизацию языка C++, как в случае применения макросов.
Шаблон дает алгоритм, используемый для автоматической генерации экземпляров функций с различными типами. Программист параметризует все или только некоторые типы в интерфейсе функции (т.е. типы формальных параметров и возвращаемого значения), оставляя ее тело неизменным. Функция хорошо подходит на роль шаблона, если ее реализация остается инвариантной на некотором множестве экземпляров, различающихся типами данных, как, скажем, в случае min().
Так определяется шаблон функции min():
template <class Type>
Type min2( Type a, Type b ) {
return a < b ? a : b;
}
int main() {
// правильно: min( int, int );
min( 10, 20 );
// правильно: min( double, double );
min( 10.0, 20.0 );
return 0;
}
Если вместо макроса препроцессора min() подставить в текст предыдущей программы этот шаблон, то результат будет правильным:
elem_cnt : 10 expecting: 10
(В стандартной библиотеке C++ есть шаблоны функций для многих часто используемых алгоритмов, например для min(). Эти алгоритмы описываются в главе 12. А в данной вводной главе мы приводим собственные упрощенные версии некоторых алгоритмов из стандартной библиотеки.)
Как объявление, так и определение шаблона функции всегда должны начинаться с ключевого слова template, за которым следует список разделенных запятыми идентификаторов, заключенный в угловые скобки '<' и '>', – список параметров шаблона, обязательно непустой. У шаблона могут быть параметры-типы, представляющие некоторый тип, и параметры-константы, представляющие фиксированное константное выражение.
Параметр-тип состоит из ключевого слова class или ключевого слова typename, за которым следует идентификатор. Эти слова всегда обозначают, что последующее имя относится к встроенному или определенному пользователем типу. Имя параметра шаблона выбирает программист. В приведенном примере мы использовали имя Type, но могли выбрать и любое другое:
template <class Glorp>
Glorp min2( Glorp a, Glorp b ) {
return a < b ? a : b;
}
При конкретизации ( порождении конкретного экземпляра) шаблона вместо параметра-типа подставляется фактический встроенный или определенный пользователем тип. Любой из типов int, double, char*, vector<int> или list<double> является допустимым аргументом шаблона.
Параметр-константа выглядит как обычное объявление. Он говорит о том, что вместо имени параметра должно быть подставлено значение константы из определения шаблона. Например, size – это параметр-константа, который представляет размер массива arr:
template <class Type, int size>
Type min( Type (&arr) [size] );
Вслед за списком параметров шаблона идет объявление или определение функции. Если не обращать внимания на присутствие параметров в виде спецификаторов типа или констант, то определение шаблона функции выглядит точно так же, как и для обычных функций:
template <class Type, int size>
Type min( const 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;
}
В этом примере Type определяет тип значения, возвращаемого функцией min(), тип параметра r_array и тип локальной переменной min_val; size задает размер массива r_array. В ходе работы программы при использовании функции min() вместо Type могут быть подставлены любые встроенные и определенные пользователем типы, а вместо size – те или иные константные выражения. (Напомним, что работать с функцией можно двояко: вызвать ее или взять ее адрес).
Процесс подстановки типов и значений вместо параметров называется конкретизацией шаблона. (Подробнее мы остановимся на этом в следующем разделе.)
Список параметров нашей функции min() может показаться чересчур коротким. Как было сказано в разделе 7.3, когда параметром является массив, передается указатель на его первый элемент, первая же размерность фактического аргумента-массива внутри определения функции неизвестна. Чтобы обойти эту трудность, мы объявили первый параметр min() как ссылку на массив, а второй – как его размер. Недостаток подобного подхода в том, что при использовании шаблона с массивами одного и того же типа int, но разных размеров генерируются (или конкретизируются) различные экземпляры функции min().
Имя параметра разрешено употреблять внутри объявления или определения шаблона. Параметр-тип служит спецификатором типа; его можно использовать точно так же, как спецификатор любого встроенного или пользовательского типа, например в объявлении переменных или в операциях приведения типов. Параметр-константа применяется как константное значение – там, где требуются константные выражения, например для задания размера в объявлении массива или в качестве начального значения элемента перечисления.
// size определяет размер параметра-массива и инициализирует
// переменную типа const int
template <class Type, int size>
Type min( const Type (&r_array)[size] )
{
const int loc_size = size;
Type loc_array[loc_size];
// ...
}
Если в глобальной области видимости объявлен объект, функция или тип с тем же именем, что у параметра шаблона, то глобальное имя оказывается скрытым. В следующем примере тип переменной tmp не double, а тот, что у параметра шаблона Type:
typedef double Type;
template <class Type>
Type min( Type a, Type b )
{
// tmp имеет тот же тип, что параметр шаблона Type, а не заданный
// глобальным typedef
Type tm = a < b ? a : b;
return tmp;
}
Объект или тип, объявленные внутри определения шаблона функции, не могут иметь то же имя, что и какой-то из параметров:
template <class Type>
Type min( Type a, Type b )
{
// ошибка: повторное объявление имени Type, совпадающего с именем
// параметра шаблона
typedef double Type;
Type tmp = a < b ? a : b;
return tmp;
}
Имя параметра-типа шаблона можно использовать для задания типа возвращаемого значения:
// правильно: T1 представляет тип значения, возвращаемого min(),
// а T2 и T3 – параметры-типы этой функции
template <class T1, class T2, class T3>
T1 min( T2, T3 );
В одном списке параметров некоторое имя разрешается употреблять только один раз. Например, следующее определение будет помечено как ошибка компиляции:
// ошибка: неправильное повторное использование имени параметра Type
template <class Type, class Type>
Type min( Type, Type );
Однако одно и то же имя можно многократно применять внутри объявления или определения шаблона:
// правильно: повторное использование имени Type внутри шаблона
template <class Type>
Type min( Type, Type );
template <class Type>
Type max( Type, Type );
Имена параметров в объявлении и определении не обязаны совпадать. Так, все три объявления min() относятся к одному и тому же шаблону функции:
// все три объявления min() относятся к одному и тому же шаблону функции
// опережающие объявления шаблона
template <class T> T min( T, T );
template <class U> U min( U, U );
// фактическое определение шаблона
template <class Type>
Type min( Type a, Type b ) { /* ... */ }
Количество появлений одного и того же параметра шаблона в списке параметров функции не ограничено. В следующем примере Type используется для представления двух разных параметров:
#include <vector>
// правильно: Type используется неоднократно в списке параметров шаблона
template <class Type>
Type sum( const vector<Type> &, Type );
Если шаблон функции имеет несколько параметров-типов, то каждому из них должно предшествовать ключевое слово class или typename:
// правильно: ключевые слова typename и class могут перемежаться
template <typename T, class U>
T minus( T*, U );
// ошибка: должно быть <typename T, class U> или
// <typename T, typename U>
template <typename T, U>
T sum( T*, U );
В списке параметров шаблона функции ключевые слова typename и class имеют одинаковый смысл и, следовательно, взаимозаменяемы. Любое из них может использоваться для объявления разных параметров-типов шаблона в одном и том же списке (как было продемонстрировано на примере шаблона функции minus()). Для обозначения параметра-типа более естественно, на первый взгляд, употреблять ключевое слово typename, а не class, ведь оно ясно указывает, что за ним следует имя типа. Однако это слово было добавлено в язык лишь недавно, как часть стандарта C++, поэтому в старых программах вы скорее всего встретите слово class. (Не говоря уже о том, что class короче, чем typename, а человек по природе своей ленив.)
Ключевое слово typename упрощает разбор определений шаблонов. (Мы лишь кратко остановимся на том, зачем оно понадобилось. Желающим узнать об этом подробнее рекомендуем обратиться к книге Страуструпа “Design and Evolution of C++”.)
При таком разборе компилятор должен отличать выражения-типы от тех, которые таковыми не являются; выявить это не всегда возможно. Например, если компилятор встречает в определении шаблона выражение Parm::name и если Parm – это параметр-тип, представляющий класс, то следует ли считать, что name представляет член-тип класса Parm?
template <class Parm, class U>
Parm minus( Parm* array, U value )
{
Parm::name * p; // это объявление указателя или умножение?
// На самом деле умножение
}
Компилятор не знает, является ли name типом, поскольку определение класса, представленного параметром Parm, недоступно до момента конкретизации шаблона. Чтобы такое определение шаблона можно было разобрать, пользователь должен подсказать компилятору, какие выражения включают типы. Для этого служит ключевое слово typename. Например, если мы хотим, чтобы выражение Parm::name в шаблоне функции minus() было именем типа и, следовательно, вся строка трактовалась как объявление указателя, то нужно модифицировать текст следующим образом:
template <class Parm, class U>
Parm minus( Parm* array, U value )
{
typename Parm::name * p; // теперь это объявление указателя
}
Ключевое слово typename используется также в списке параметров шаблона для указания того, что параметр является типом.
Шаблон функции можно объявлять как inline или extern – как и обычную функцию. Спецификатор помещается после списка параметров, а не перед словом template.
// правильно: спецификатор после списка параметров
template <typename Type>
inline
Type min( Type, Type );
// ошибка: спецификатор inline не на месте
inline
template <typename Type>
Type min( Array<Type>, int );
Упражнение 10.1
Определите, какие из данных определений шаблонов функций неправильны. Исправьте ошибки.
(a) template <class T, U, class V>
void foo( T, U, V );
(b) template <class T>
T foo( int *T );
(c) template <class T1, typename T2, class T3>
T1 foo( T2, T3 );
(d) inline template <typename T>
T foo( T, unsigned int* );
(e) template <class myT, class myT>
void foo( myT, myT );
(f) template <class T>
foo( T, T );
(g) typedef char Ctype;
template <class Ctype>
Ctype foo( Ctype a, Ctype b );
Упражнение 10.2
Какие из повторных объявлений шаблонов ошибочны? Почему?
(a) template <class Type>
Type bar( Type, Type );
template <class Type>
Type bar( Type, Type );
(b) template <class T1, class T2>
void bar( T1, T2 );
template <typename C1, typename C2>
void bar( C1, C2 );
Упражнение 10.3
Перепишите функцию putValues() из раздела 7.3.3 в виде шаблона. Параметризуйте его так, чтобы было два параметра шаблона (для типа элементов массива и для размера массива) и один параметр функции, являющийся ссылкой на массив. Напишите определение шаблона функции.
Определение шаблона класса
Предположим, что нам нужно определить класс, поддерживающий механизм очереди. Очередь– это структура данных для хранения коллекции объектов; они помещаются в конец очереди, а извлекаются из ее начала. Поведение очереди описывают аббревиатурой FIFO – “первым пришел, первым ушел”. (Определенный в стандартной библиотеке C++ тип, реализующий очередь, упоминался в разделе 6.17. В этой главе мы создадим упрощенный тип для знакомства с шаблонами классов.)
Необходимо, чтобы наш класс Queue поддерживал следующие операции:
добавить элемент в конец очереди:
void add( item );
удалить элемент из начала очереди:
item remove();
определить, пуста ли очередь:
bool is_empty();
определить, заполнена ли очередь:
bool is_full();
Определение Queue могло бы выглядеть так:
class Queue {
public:
Queue();
~Queue();
Type& remove();
void add( const Type & );
bool is_empty();
bool is_full();
private:
// ...
};
Вопрос в том, какой тип использовать вместо Type? Предположим, что мы решили реализовать класс Queue, заменив Type на int. Тогда Queue может управлять коллекциями объектов типа int. Если бы понадобилось поместить в очередь объект другого типа, то его пришлось бы преобразовать в тип int, если же это невозможно, компилятор выдаст сообщение об ошибке:
Queue qObj;
string str( "vivisection" );
qObj.add( 3.14159 ); // правильно: в очередь помещен объект 3
qObj.add( str ); // ошибка: нет преобразования из string в int
Поскольку любой объект в коллекции имеет тип int, то язык C++ гарантирует, что в очередь можно поместить либо значение типа int, либо значение, преобразуемое в такой тип. Это подходит, если предстоит работа с очередями объектов только типа int. Если же класс Queue должен поддерживать также коллекции объектов типа double, char, комплексные числа или строки, подобная реализация оказывается слишком ограничительной.
Конечно, эту проблему можно решить, создав копию класса Queue для работы с типом double, затем для работы с комплексными числами, затем со строками и т.д. А поскольку имена классов перегружать нельзя, каждой реализации придется дать уникальное имя: IntQueue, DoubleQueue, ComplexQueue, StringQueue. При необходимости работать с другим классом придется снова копировать, модифицировать и переименовывать.
Такой метод дублирования кода крайне неудобен. Создание различных уникальных имен для Queue представляет лексическую сложность. Имеются и трудности администрирования: любое изменение общего алгоритма придется вносить в каждую реализацию класса. В общем случае процесс ручной генерации копий для индивидуальных типов никогда не кончается и очень сложен с точки зрения сопровождения.
К счастью, механизм шаблонов C++ позволяет автоматически генерировать такие типы. Шаблон класса можно использовать при создании Queue для очереди объектов любого типа. Определение шаблона этого класса могло бы выглядеть следующим образом:
template <class Type>
class Queue {
public:
Queue();
~Queue();
Type& remove();
void add( const Type & );
bool is_empty();
bool is_full();
private:
// ...
};
Чтобы создать классы Queue, способные хранить целые числа, комплексные числа и строки, программисту достаточно написать:
Queue<int> qi;
Queue< complex<double> > qc;
Queue<string> qs;
Реализация Queue представлена в следующих разделах с целью иллюстрации определения и применения шаблонов классов. В реализации используются две абстракции шаблона:
сам шаблон класса Queue предоставляет описанный выше открытый интерфейс и пару членов: front и back. Очередь реализуется с помощью связанного списка;
шаблон класса QueueItem представляет один узел связанного списка Queue. Каждый помещаемый в очередь элемент сохраняется в объекте QueueItem, который содержит два члена: value и next. Тип value будет различным в каждом экземпляре класса Queue, а next – это всегда указатель на следующий объект QueueItem в очереди.
Прежде чем приступать к детальному изучению реализации этих шаблонов, рассмотрим, как они объявляются и определяются. Вот объявление шаблона класса QueueItem:
template <class T>
class QueueItem;
Как объявление, так и определение шаблона всегда начинаются с ключевого слова template. За ним следует заключенный в угловые скобки список параметров шаблона, разделенных запятыми. Список не бывает пустым. В нем могут быть параметры-типы, представляющие некоторый тип, и параметры-константы, представляющие некоторое константное выражение.
Параметр- тип шаблона состоит из ключевого слова class или typename (в списке параметров они эквивалентны), за которым следует идентификатор. (Ключевое слово typename не поддерживается компиляторами, написанными до принятия стандарта C++. В разделе 10.1 подробно объяснялось, зачем это слово было добавлено в язык.) Оба ключевых слова обозначают, что последующее имя параметра относится к встроенному или определенному пользователем типу. Например, в приведенном выше определении шаблона QueueItem имеется один параметр-тип T. Допустимым фактическим аргументом для T является любой встроенный или определенный пользователем тип, такой, как int, double, char*, complex или string.
У шаблона класса может быть несколько параметров-типов:
template <class T1, class T2, class T3>
class Container;
Однако ключевое слово class или typename должно предшествовать каждому. Следующее объявление ошибочно:
// ошибка: должно быть <typename T, class U> или
// <typename T, typename U>
template <typename T, U>
class collection;
Объявленный параметр-тип служит спецификатором типа в оставшейся части определения шаблона и употребляется точно так же, как любой встроенный или определенный пользователем тип в обычном определении класса. Например, параметр-тип можно использовать для объявления данных и функций-членов, членов вложенных классов и т.д.
Не являющийся типом параметр шаблона представляет собой обычное объявление. Он показывает, что следующее за ним имя – это потенциальное значение, употребляемое в определении шаблона в качестве константы. Так, шаблон класса Buffer может иметь параметр-тип, представляющий типы элементов, хранящихся в буфере, и параметр-константу, содержащий его размер:
template <class Type, int size>
class Buffer;
За списком параметров шаблона следует определение или объявление класса. Шаблон определяется так же, как обычный класс, но с указанием параметров:
template <class Type>
class QueueItem {
public:
// ...
private:
// Type представляет тип члена
Type item;
QueueItem *next;
};
В этом примере Type используется для обозначения типа члена item. По ходу выполнения программы вместо Type могут быть подставлены различные встроенные или определенные пользователем типы. Такой процесс подстановки называется конкретизацией шаблона.
Имя параметра шаблона можно употреблять после его объявления и до конца объявления или определения шаблона. Если в глобальной области видимости объявлена переменная с таким же именем, как у параметра шаблона, то это имя будет скрыто. В следующем примере тип item равен не double, а типу параметра:
typedef double Type;
template <class Type>
class QueueItem {
public:
// ...
private:
// тип Item - не double
Type item;
QueueItem *next;
};
Член класса внутри определения шаблона не может быть одноименным его параметру:
template <class Type>
class QueueItem {
public:
// ...
private:
// ошибка: член не может иметь то же имя, что и
// параметр шаблона Type
typedef double Type;
Type item;
QueueItem *next;
};
Имя параметра шаблона может встречаться в списке только один раз. Поэтому следующее объявление компилятор помечает как ошибку:
// ошибка: неправильное использование имени параметра шаблона Type
template <class Type, class Type>
class container;
Такое имя разрешается повторно использовать в объявлениях или определениях других шаблонов:
// правильно: повторное использование имени Type в разных шаблонах
template <class Type>
class QueueItem;
template <class Type>
class Queue;
Имена параметров в опережающем объявлении и последующем определении одного и того же шаблона не обязаны совпадать. Например, все эти объявления QueueItem относятся к одному шаблону класса:
// все три объявления QueueItem
// относятся к одному и тому же шаблону класса
// объявления шаблона
template <class T> class QueueItem;
template <class U> class QueueItem;
// фактическое определение шаблона
template <class Type>
class QueueItem { ... };
У параметров могут быть аргументы по умолчанию (это справедливо как для параметров-типов, так и для параметров-констант) – тип или значение, которые используются в том случае, когда при конкретизации шаблона фактический аргумент не указан. В качестве такого аргумента следует выбирать тип или значение, подходящее для большинства конкретизаций. Например, если при конкретизации шаблона класса Buffer не указан размер буфера, то по умолчанию принимается 1024:
template <class Type, size = 1024>
class Buffer;
В последующих объявлениях шаблона могут быть заданы дополнительные аргументы по умолчанию. Как и в объявлениях функций, если для некоторого параметра задан такой аргумент, то он должен быть задан и для всех параметров, расположенных в списке правее (даже в другом объявлении того же шаблона):
template <class Type, size = 1024>
class Buffer;
// правильно: рассматриваются аргументы по умолчанию из обоих объявлений
template <class Type=string, int size>
class Buffer;
(Отметим, что аргументы по умолчанию для параметров шаблонов не поддерживаются в компиляторах, реализованных до принятия стандарта C++. Чтобы примеры из этой книги, в частности из главы 12, компилировались большинством современных компиляторов, мы не использовали такие аргументы.)
Внутри определения шаблона его имя можно применять как спецификатор типа всюду, где допустимо употребление имени обычного класса. Вот более полная версия определения шаблона QueueItem:
template <class Type>
class QueueItem {
public:
QueueItem( const Type & );
private:
Type item;
QueueItem *next;
};
Обратите внимание, что каждое появление имени QueueItem в определении шаблона – это сокращенная запись для
QueueItem<Type>
Такую сокращенную нотацию можно употреблять только внутри определения QueueItem (и, как мы покажем в следующих разделах, в определениях его членов, которые находятся вне определения шаблона класса). Если QueueItem применяется как спецификатор типа в определении какого-либо другого шаблона, то необходимо задавать полный список параметров. В следующем примере шаблон класса используется в определении шаблона функции display. Здесь за именем шаблона класса QueueItem должны идти параметры, т.е. QueueItem<Type>.
template <class Type>
void display( QueueItem<Type> &qi )
{
QueueItem<Type> *pqi = &qi;
// ...
}
Определения пространства имен *
По умолчанию любой объект, функция, тип или шаблон, объявленный в глобальной области видимости, также называемой областью видимости глобального пространства имен, вводит глобальную сущность. Каждая такая сущность обязана иметь уникальное имя. Например, функция и объект не могут быть одноименными, даже если они объявлены в разных исходных файлах.
Таким образом, используя в своей программе некоторую библиотеку, мы должны быть уверены, что имена глобальных сущностей нашей программы не совпадают с именами из библиотеки. Это нелегко, если мы работаем с библиотеками разных производителей, где определено много глобальных имен. Собирая программу с такими библиотеками, нельзя гарантировать, что имена глобальных сущностей не будут вступать в конфликт.
Обойти эту проблему, названную проблемой засорения области видимости глобального пространства имен, можно посредством очень длинных имен. Часто в качестве их префикса употребляется определенная последовательность символов. Например:
class cplusplus_primer_matrix { ... };
void inverse( cplusplus_primer_matrix & );
Однако у этого решения есть недостаток. Программа, написанная на С++, может содержать множество глобальных классов, функций и шаблонов, видимых в любой точке кода. Работать со слишком длинными идентификаторами для программистов утомительно.
Пространства имен помогают справиться с проблемой засорения более удобным способом. Автор библиотеки может задать собственное пространство и таким образом вынести используемые в библиотеке имена из глобальной области видимости:
namespace cplusplus_primer {
class matrix { /*...*/ };
void inverse ( matrix & );
}
cplusplus_primer является пользовательским пространством имен (в отличие от глобального пространства, которое неявно подразумевается и существует в любой программе).
Каждое такое пространство представляет собой отдельную область видимости. Оно может содержать вложенные определения пространств имен, а также объявления или определения функций, объектов, шаблонов и типов. Все сущности, объявленные внутри некоторого пространства имен, называются его членами. Каждое имя в пользовательском пространстве, как и в глобальном, должно быть уникальным в пределах этого пространства.
Однако в разных пользовательских пространствах могут встречаться члены с одинаковыми именами.
Имя члена пространства имен автоматически дополняется, или квалифицируется, именем этого пространства. Например, имя класса matrix, объявленное в пространстве cplusplus_primer, становится cplusplus_primer::matrix, а имя функции inverse() превращается в cplusplus_primer::inverse().
Члены cplusplus_primer могут использоваться в программе с помощью спецификации имени:
void func( cplusplus_primer::matrix &m )
{
// ...
cplusplus_primer::inverse(m);
return m;
}
Если в другом пользовательском пространстве имен (скажем, DisneyFeatureAnimation) также существует класс matrix и функция inverse() и мы хотим использовать этот класс вместо объявленного в пространстве cplusplus_primer, то функцию func() нужно модифицировать следующим образом:
void func( DisneyFeatureAnimation::matrix &m )
{
// ...
DisneyFeatureAnimation::inverse(m);
return m;
}
Конечно, каждый раз указывать специфицированные имена типа
namespace_name::member_name
неудобно. Поэтому существуют механизмы, позволяющие облегчить использование пространств имен в программах. Это псевдонимы пространств имен, using-объявления и using-директивы. (Мы рассмотрим их в разделе 8.6.)
Определения пространства имен
Определение пользовательского пространства имен начинается с ключевого слова namespace, за которым следует идентификатор. Он должен быть уникальным в той области видимости, в которой определяется данное пространство; наличие другой сущности с тем же именем является ошибкой. Конечно, это не означает, что проблема засорения глобального пространства решена полностью, но существенно помогает в ее решении.
За идентификатором пространства имен следует блок в фигурных скобках, содержащий различные объявления. Любое объявление, допустимое в области видимости глобального пространства, может встречаться и в пользовательском: классы, переменные (вместе с инициализацией), функции (вместе со своими определениями), шаблоны.
Помещая объявление в пользовательское пространство, мы не меняем его семантики. Единственное отличие состоит в том, что имена, вводимые такими объявлениями, включают в себя имя пространства, внутри которого они объявлены. Например:
namespace cplusplus_primer {
class matrix { /* ... */ };
void inverse ( matrix & );
matrix operator+ ( const matrix &ml, const matrix &m2 )
{/* ... */ }
const double pi = 3.1416;
}
Именем класса, объявленного в пространстве cplusplus_primer, будет
cplusplus_primer::matrix
Именем функции
cplusplus_primer::inverse()
Именем константы
cplusplus_primer::pi
Имя класса, функции или константы расширяется именем пространства, в котором они объявлены. Такие имена называют квалифицированными.
Определение пространства имен не обязательно должно быть непрерывным. Например, предыдущее пространство могло быть определено таким образом:
namespace cplusplus_primer {
class matrix { /* ... */ };
const double pi = 3.1416;
}
namespace cplusplus_primer {
void inverse ( matrix & );
matrix operator+ ( const matrix &ml, const matrix &m2 )
{/* ... */ }
}
Два приведенных примера эквивалентны: оба задают пространство имен cplusplus_primer, содержащее класс matrix, функцию inverse(), константу pi и operator+(). Определение пространства имен может состоять из нескольких соединенных частей.
Последовательность
namespace namespace_name {
задает новое пространство, если имя namespace_name не совпадает с одним из ранее объявленных. В противном случае новые объявления добавляются в старое пространство.
Возможность разбить пространство имен на несколько частей помогает при организации библиотеки. Ее исходный код легко разделить на интерфейсную часть и реализацию. Например:
// Эта часть пространства имен
// определяет интерфейс библиотеки
namespace cplusplus_primer {
class matrix { /* ... */ };
const double pi = 3.1416;
matrix operator+ ( const matrix &ml, const matrix &m2 );
void inverse ( matrix & );
}
// Эта часть пространства имен
// определяет реализацию библиотеки
namespace cplusplus_primer {
void inverse ( matrix &m )
{ /* ... */ }
matrix operator+ ( const matrix &ml, const matrix &m2 )
{ /* ... */ }
}
Первая часть пространства имен содержит объявления и определения, служащие интерфейсом библиотеки: определения типов, констант, объявления функций. Во второй части находятся детали реализации, то есть определения функций.
Еще более полезной для организации исходного кода библиотеки является возможность разделить определение одного пространства имен на несколько файлов: эти определения также объединяются. Наша библиотека может быть устроена следующим образом:
// ---- primer.h ----
namespace cplusplus_primer {
class matrix { /*... */ };
const double pi = 3.1416;
matrix operator+ ( const matrix &m1, const matrix &m2 );
void inverse( matrix & );
}
// ---- primer.C ----
#include "primer.h"
namespace cplusplus_primer {
void inverse( matrix &m )
{ /* ... */ }
matrix operator+ ( const matrix &m1, const matrix &m2 )
{ /* ... */ }
}
Программа, использующая эту библиотеку, выглядит так:
// ---- user.C ----
// определение интерфейса библиотеки
#include "primer.h"
void func( cplusplus_primer::matrix &m )
{
//...
cplusplus_primer: :inverse( m );
return m;
}
Подобная организация программы обеспечивает модульность библиотеки, необходимую для сокрытия реализации от пользователей, в то же время позволяя без ошибок скомпилировать и связать файлы primer.C и user.C в одну программу.
Определения шаблонов классов Queue и QueueItem
Ниже представлено определение шаблона класса Queue. Оно помещено в заголовочный файл Queue.h вместе с определением шаблона QueueItem:
#ifndef QUEUE_H
#define QUEUE_H
// объявление QueueItem
template <class T> class QueueItem;
template <class Type>
class Queue {
public:
Queue() : front( 0 ), back ( 0 ) { }
~Queue();
Type& remove();
void add( const Type & );
bool is_empty() const {
return front == 0;
}
private:
QueueItem<Type> *front;
QueueItem<Type> *back;
};
#endif
При использовании имени Queue внутри определения шаблона класса Queue список параметров <Type> можно опускать. Однако пропуск списка параметров шаблона QueueItem в определении шаблона Queue недопустим. Так, объявление члена front является ошибкой:
template <class Type>
class Queue {
public:
// ...
private:
// ошибка: список параметров для QueueItem неизвестен
QueueItem<Type> *front;
}
Упражнение 16.1
Найдите ошибочные объявления (или пары объявлений) шаблонов классов:
(a) template <class Type>
class Container1;
template <class Type, int size>
class Container1;
(b) template <class T, U, class V>
class Container2;
(c) template <class C1, typename C2>
class Container3 {};
(d) template <typename myT, class myT>
class Container4 {};
(e) template <class Type, int *pi>
class Container5;
(f) template <class Type, int val = 0>
class Container6;
template <class T = complex<double>, int v>
class Container6;
Упражнение 16.2
Следующее определение шаблона List некорректно. Как исправить ошибку?
template <class elemenType>
class ListItem;
template <class elemType>
class List {
public:
List<elemType>()
: _at_front( 0 ), _at_end( 0 ), _current( 0 ), _size( 0 )
{}
List<elemType>( const List<elemType> & );
List<elemType>& operator=( const List<elemType> & );
~List();
void insert( ListItem *ptr, elemType value );
int remove( elemType value );
ListItem *find( elemType value );
void display( ostream &os = cout );
int size() { return _size; }
private:
ListItem *_at_front;
ListItem *_at_end;
ListItem *_current;
int _size
};
Определенные пользователем преобразования
Мы уже видели, как преобразования типов применяются к операндам встроенных типов: в разделе 4.14 этот вопрос рассматривался на примере операндов встроенных операторов, а в разделе 9.3 – на примере фактических аргументов вызванной функции для приведения их к типам формальных параметров. Рассмотрим с этой точки зрения следующие шесть операций сложения:
char ch; short sh;, int ival;
/* в каждой операции один операнд
* требует преобразования типа */
ch + ival; ival + ch;
ch + sh; ch + ch;
ival + sh; sh + ival;
Операнды ch и sh расширяются до типа int. При выполнении операции складываются два значения типа int. Расширение типа неявно выполняется компилятором и для пользователя прозрачно.
В этом разделе мы рассмотрим, как разработчик может определить собственные преобразования для объектов типа класса. Такие определенные пользователем преобразования также автоматически вызываются компилятором по мере необходимости. Чтобы показать, зачем они нужны, обратимся снова к классу SmallInt, введенному в разделе 10.9.
Напомним, что SmallInt позволяет определять объекты, способные хранить значения из того же диапазона, что unsigned char, т.е. от 0 до 255, и перехватывает ошибки выхода за его границы. Во всех остальных отношениях этот класс ведет себя точно так же, как unsigned char.
Чтобы иметь возможность складывать объекты SmallInt с другими объектами того же класса или со значениями встроенных типов, а также вычитать их, реализуем шесть операторных функций:
class SmallInt {
friend operator+( const SmallInt &, int );
friend operator-( const SmallInt &, int );
friend operator-( int, const SmallInt & );
friend operator+( int, const SmallInt & );
public:
SmallInt( int ival ) : value( ival ) { }
operator+( const SmallInt & );
operator-( const SmallInt & );
// ...
private:
int value;
};
Операторы-члены дают возможность складывать и вычитать два объекта SmallInt. Глобальные же операторы-друзья позволяют производить эти операции над объектами данного класса и объектами встроенных арифметических типов. Необходимо только шесть операторов, поскольку любой встроенный арифметический тип может быть приведен к типу int. Например, выражение
SmallInt si( 3 );
si + 3.14159
разрешается в два шага:
1. Константа 3.14159 типа double преобразуется в целое число 3.
2. Вызывается operator+(const SmallInt &,int), который возвращает значение 6.
Если мы хотим поддержать битовые и логические операции, а также операции сравнения и составные операторы присваивания, то сколько же необходимо перегрузить операторов? Сразу и не сосчитаешь. Значительно удобнее автоматически преобразовать объект класса SmallInt в объект типа int.
В языке C++ имеется механизм, позволяющий в любом классе задать набор преобразований, применимых к его объектам. Для SmallInt мы определим приведение объекта к типу int. Вот его реализация:
class SmallInt {
public:
SmallInt( int ival ) : value( ival ) { }
// конвертер
// SmallInt ==> int
operator int() { return value; }
// перегруженные операторы не нужны
private:
int value;
};
Оператор int() – это конвертер, реализующий определенное пользователем преобразование, в данном случае приведение типа класса к заданному типу int. Определение конвертера описывает, что означает преобразование и какие действия компилятор должен выполнить для его применения. Для объекта SmallInt смысл преобразования в int заключается в том, чтобы вернуть число типа int, хранящееся в члене value.
Теперь объект класса SmallInt можно использовать всюду, где допустимо использование int. Если предположить, что перегруженных операторов больше нет и в SmallInt определен конвертер в int, операция сложения
SmallInt si( 3 );
si + 3.14159
разрешается двумя шагами:
1. Вызывается конвертер класса SmallInt, который возвращает целое число 3.
2. Целое число 3 расширяется до 3.0 и складывается с константой двойной точности 3.14159, что дает 6.14159.
Такое поведение больше соответствует поведению операндов встроенных типов по сравнению с определенными ранее перегруженными операторами. Когда значение типа int складывается со значением типа double, то выполняется сложение двух чисел типа double (поскольку тип int расширяется до double) и результатом будет число того же типа.
В этой программе иллюстрируется применение класса SmallInt:
#include <iostream>
#include "SmallInt.h"
int main() {
cout << "Введите SmallInt, пожалуйста: ";
while ( cin >> si1 ) {
cout << "Прочитано значение "
<< si1 << "\nОно ";
// SmallInt::operator int() вызывается дважды
cout << ( ( si1 > 127 )
? "больше, чем "
: ( ( si1 < 127 )
? "меньше, чем "
: "равно ") ) << "127\n";
cout << "\Введите SmallInt, пожалуйста \
(ctrl-d для выхода): ";
}
cout <<"До встречи\n";
}
Откомпилированная программа выдает следующие результаты:
Введите SmallInt, пожалуйста: 127
Прочитано значение 127
Оно равно 127
Введите SmallInt, пожалуйста (ctrl-d для выхода): 126
Оно меньше, чем 127
Введите SmallInt, пожалуйста (ctrl-d для выхода): 128
Оно больше, чем 127
Введите SmallInt, пожалуйста (ctrl-d для выхода): 256
*** Ошибка диапазона SmallInt: 256 ***
В реализацию класса SmallInt добавили поддержку новой функциональности:
#include <iostream>
class SmallInt {
friend istream&
operator>>( istream &is, SmallInt &s );
friend ostream&
operator<<( ostream &is, const SmallInt &s )
{ return os << s.value; }
public:
SmallInt( int i=0 ) : value( rangeCheck( i ) ){}
int operator=( int i )
{ return( value = rangeCheck( i ) ); }
operator int() { return value; }
private:
int rangeCheck( int );
int value;
};
Ниже приведены определения функций-членов, находящиеся вне тела класса:
istream& operator>>( istream &is, SmallInt &si ) {
int ix;
is >> ix;
si = ix; // SmallInt::operator=(int)
return is;
}
int SmallInt::rangeCheck( int i )
{
/* если установлен хотя бы один бит, кроме первых восьми,
* то значение слишком велико; сообщить и сразу выйти */
if ( i & ~0377 ) {
cerr << "\n*** Ошибка диапазона SmallInt: "
<< i << " ***" << endl;
exit( -1 );
}
return i;
}
Открытие отдельных членов
Когда мы применили закрытое наследование класса PeekbackStack от IntArray, то все защищенные и открытые члены IntArray стали закрытыми членами PeekbackStack. Было бы полезно, если бы пользователи PeekbackStack могли узнать размер стека с помощью такой инструкции:
is.size();
Разработчик способен оградить некоторые члены базового класса от эффектов неоткрытого наследования. Вот как, к примеру, открывается функция-член size() класса IntArray:
class PeekbackStack : private IntArray {
public:
// сохранить открытый уровень доступа
using IntArray::size;
// ...
};
Еще одна причина для открытия отдельных членов заключается в том, что иногда необходимо разрешить доступ к защищенным членам закрыто унаследованного базового класса при последующем наследовании. Предположим, что пользователям нужен подтип стека PeekbackStack, который может динамически расти. Для этого классу, производному от PeekbackStack, понадобится доступ к защищенным элементам ia и _size класса IntArray:
template <class Type>
class PeekbackStack : private IntArray {
public:
using intArray::size;
// ...
protected:
using intArray::size;
using intArray::ia;
// ...
};
Производный класс может лишь вернуть унаследованному члену исходный уровень доступа, но не повысить или понизить его по сравнению с указанным в базовом классе.
На практике множественное наследование очень часто применяется для того, чтобы унаследовать открытый интерфейс одного класса и закрытую реализацию другого. Например, в библиотеку классов Booch Components включена следующая реализация растущей очереди Queue (см. также статью Майкла Вило (Michaeel Vilot) и Грейди Буча (Grady Booch) в [LIPPMAN96b]):
template < class item, class container >
class Unbounded_Queue:
private Simple_List< item >, // реализация
public Queue< item > // интерфейс
{ ... }
Открытое, закрытое и защищенное наследование
Открытое наследование называется еще наследованием типа. Производный класс в этом случае является подтипом базового; он замещает реализации всех функций-членов, специфичных для типа базового класса, и наследует общие для типа и подтипа функции. Можно сказать, что производный класс служит примером отношения “ЯВЛЯЕТСЯ”, т.е. предоставляет специализацию более общего базового класса. Медведь (Bear) является животным из зоопарка (ZooAnimal); аудиокнига (AudioBook) является предметом, выдаваемым читателям (LibraryLendingMaterial). Мы говорим, что Bear– это подтип ZooAnimal, равно как и Panda. Аналогично AudioBook – подтип LibBook (библиотечная книга), а оба они – подтипы LibraryLendingMaterial. В любом месте программы, где ожидается базовый тип, можно вместо него подставить открыто унаследованный от него подтип, и программа будет продолжать работать правильно (при условии, конечно, что подтип реализован корректно). Во всех приведенных выше примерах демонстрировалось именно наследование типа.
Закрытое наследование называют также наследованием реализации. Производный класс напрямую не поддерживает открытый интерфейс базового, но пользуется его реализацией, предоставляя свой собственный открытый интерфейс.
Чтобы показать, какие здесь возникают вопросы, реализуем класс PeekbackStack, который поддерживает выборку из стека с помощью метода peekback():
bool
PeekbackStack::
peekback( int index, type &value ) { ... }
где value содержит элемент в позиции index, если peekback() вернула true. Если же peekback() возвращает false, то заданная аргументом index позиция некорректна и в value помещается элемент из вершины стека.
В реализации PeekbackStack возможны два типа ошибок:
реализация абстракции PeekbackStack: некорректная реализация поведения класса;
реализация представления данных: неправильное управление выделением и освобождением памяти, копированием объектов из стека и т.п.
Обычно стек реализуется либо как массив, либо как связанный список элементов (в стандартной библиотеке по умолчанию это делается на базе двусторонней очереди, хотя вместо нее можно использовать вектор, см. главу 6). Хотелось бы иметь гарантированно правильную (или, по крайней мере, хорошо протестированную и поддерживаемую) реализацию массива или списка, чтобы использовать ее в нашем классе PeekbackStack. Если она есть, то можно сосредоточиться на правильности поведения стека.
У нас есть класс IntArray, представленный в разделе 2.3 (мы временно откажемся от применения класса deque из стандартной библиотеки и от поддержки элементов, имеющих отличный от int тип). Вопрос, таким образом, заключается в том, как лучше всего воспользоваться классом IntArray в нашей реализации PeekbackStack. Можно задействовать механизм наследования. (Отметим, что для этого нам придется модифицировать IntArray, сделав его члены защищенными, а не закрытыми.) Реализация выглядела бы так:
#include "IntArray.h"
class PeekbackStack : public IntArray {
private:
const int static bos = -1;
public:
explicit PeekbackStack( int size )
: IntArray( 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 _ia[ _top-- ];
}
void push( int value ) {
if ( full() )
/* обработать ошибку */ ;
_ia[ ++_top ] = value;
}
bool peekback( int index, int &value ) const;
private:
int _top;
};
inline bool
PeekbackStack::
peekback( int index, int &value ) const
{
if ( empty() )
/* обработать ошибку */ ;
if ( index < 0 || index > _top )
{
value = _ia[ _top ];
return false;
}
value = _ia[ index ];
return true;
}
К сожалению, программа, которая работает с нашим новым классом PeekbackStack, может неправильно использовать открытый интерфейс базового IntArray:
extern void swap( IntArray&, int, int );
PeekbackStack is( 1024 );
// непредвиденное ошибочное использование PeekbackStack
swap(is, i, j);
is.sort();
is[0] = is[512];
Абстракция PeekbackStack должна обеспечить доступ к элементам стека по принципу “последним пришел, первым ушел”. Однако наличие дополнительного интерфейса IntArray не позволяет гарантировать такое поведение.
Проблема в том, что открытое наследование описывается как отношение “ЯВЛЯЕТСЯ”. Но PeekbackStack не является разновидностью массива IntArray, а лишь включает его как часть своей реализации. Открытый интерфейс IntArray не должен входить в открытый интерфейс PeekbackStack.
Закрытое наследование от базового класса представляет собой вид наследования, который нельзя описать в терминах подтипов. В производном классе открытый интерфейс базового становится закрытым. Все показанные выше примеры использования объекта PeekbackStack становятся допустимыми только внутри функций-членов и друзей производного класса.
В приведенном ранее определении PeekbackStack достаточно заменить слово public в списке базовых классов на private. Внутри же самого определения класса public и private следует оставить на своих местах:
class PeekbackStack : private IntArray { ... };
Отложенное обнаружение ошибок
Начинающие программисты часто удивляются, почему некорректные определения классов AndQuery и OrQuery (в которых отсутствуют необходимые объявления конструкторов) компилируются без ошибок. Если бы мы не попытались определить фактический объект класса AndQuery, в этой модифицированной иерархии так и осталась бы ненайденная ошибка. Дело в том, что:
если ошибка обнаруживается в точке объявления, то мы не можем продолжать компиляцию приложения, пока не исправим ее. Если же конфликтующее объявление – это часть библиотеки, для которой у нас нет исходного текста, то разрешение конфликта может оказаться нетривиальной задачей. Более того, возможно, в нашем коде никогда и не возникнет ситуации, когда эта ошибка проявляется, так что для нас она останется лишь потенциальной угрозой;
с другой стороны, если ошибка не найдена вплоть до момента использования, то код может оказаться замусоренным ошибками, проявляющимися в самый неподходящий момент к удивлению программиста. При такой стратегии успешная компиляция говорит не об отсутствии семантических ошибок, а лишь о том, что программа не исполняет код, нарушающий семантические правила языка.
Выдача сообщения об ошибке в точке использования – это одна из форм отложенного вычисления, распространенного метода повышения производительности программ. Он часто применяется для того, чтобы отложить потенциально дорогую операцию выделения или инициализации ресурса до момента, когда в нем возникнет реальная необходимость. Если ресурс так и не понадобится, мы сэкономим на ненужных подготовительных операциях. Если же он потребуется, но не сразу, мы растянем инициализацию программы на более длительный период.
В C++ потенциальные ошибки “комбинирования”, связанные с перегруженными функциями, шаблонами и наследованием классов, обнаруживаются в точке использования, а не в точке объявления. (Мы полагаем, что это правильно, поскольку необходимость выявлять все возможные ошибки, которые можно допустить в результате комбинирования многочисленных компонентов, – пустая трата времени). Следовательно, для обнаружения и устранения латентных ошибок необходимо тщательно тестировать код. Подобные ошибки, возникающие при комбинировании двух или более больших компонентов, допустимы; однако в пределах одного компонента, такого, как иерархия классов Query, их быть не должно.
Параметры и тип возврата
Вернемся к задаче, сформулированной в начале данного раздела. Как использовать указатели на функции для сортировки элементов? Мы можем передать в алгоритм сортировки указатель на функцию, которая выполняет сравнение:
int sort( string*, string*,
int (*)( const string &, const string & ) );
И в этом случае директива typedef помогает сделать объявление sort() более понятным:
// Использование директивы typedef делает
// объявление sort() более понятным
typedef int ( *PFI2S )( const string &, const string & );
int sort( string*, string*, PFI2S );
Поскольку в большинстве случаев употребляется функция lexicoCompare, можно использовать значение параметра по умолчанию:
// значение по умолчанию для третьего параметра
int lexicoCompare( const string &, const string & );
int sort( string*, string*, PFI2S = lexicoCompare );
Определение sort() выглядит следующим образом:
1 void sort( string *sl, string *s2,
2 PFI2S compare = lexicoCompare )
3 {
4 // условие окончания рекурсии
5 if ( si < s2 ) {
6 string elem = *s1;
7 string *1ow = s1;
8 string *high = s2 + 1;
9
10 for (;;) {
11 while ( compare ( *++1ow, elem ) < 0 && low < s2) ;
12 while ( compare( elem, *--high ) < 0 && high > s1)
14 if ( low < high )
15 1ow->swap(*high);
16 else break;
17 } // end, for(;;)
18
19 s1->swap(*high);
20 sort( s1, high - 1 );
21 sort( high +1, s2 );
22 } // end, if ( si < s2 )
23 }
sort() реализует алгоритм быстрой сортировки Хоара (C.A.R.Hoare). Рассмотрим ее определение детально. Она сортирует элементы массива от s1 до s2. Это рекурсивная функция, которая вызывает сама себя для последовательно уменьшающихся подмассивов. Рекурсия окончится тогда, когда s1 и s2 укажут на один и тот же элемент или s1 будет располагаться после s2 (строка 5).
elem (строка 6) является разделяющим элементом. Все элементы, меньшие чем elem, перемещаются влево от него, а большие– вправо. Теперь массив разбит на две части. sort() рекурсивно вызывается для каждой из них (строки 20-21).
Цикл for(;;) проводит разделение (строки 10-17). На каждой итерации цикла индекс low увеличивается до первого элемента, большего или равного elem (строка 11). Аналогично high уменьшается до последнего элемента, меньшего или равного elem (строка 12). Когда low становится равным или большим high, мы выходим из цикла, в противном случае нужно поменять местами значения элементов и начать новую итерацию (строки 14-16). Хотя элементы разделены, elem все еще остается первым в массиве. swap() в строке 19 ставит его на место до рекурсивного вызова sort() для двух частей массива.
Сравнение производится вызовом функции, на которую указывает compare (строки 11-12). Чтобы поменять элементы массива местами, используется операция swap() с аргументами типа string, представленная в разделе 6.11.
Вот как выглядит main(), в которой применяется наша функция сортировки:
#include <iostream>
#include <string>
// это должно бы находиться в заголовочном файле
int lexicoCompare( const string &, const string & );
int sizeCompare( const string &, const string & );
typedef int (*PFI)( const string &, const string & );
void sort( string *, string *, PFI=lexicoCompare );
string as[10] = { "a", "light", "drizzle", "was", "falling",
"when", "they", "left", "the", "museum" };
int main() {
// вызов sort() с значением по умолчанию параметра compare
sort( as, as + sizeof(as)/sizeof(as[0]) - 1 );
// выводим результат сортировки
for ( int i = 0; i < sizeof(as)/sizeof(as[0]); ++i )
cout << as[ i ].c_str() << "\n\t";
}
Результат работы программы:
"a"
"drizzle"
"falling"
"left"
"light"
"museum"
"the"
"they"
"was"
"when"
Параметр функции автоматически приводится к типу указателя на функцию:
// typedef представляет собой тип функции
typedef int functype( const string &, const string & );
void sort( string *, string *, functype );
sort() рассматривается компилятором как объявленная в виде
void sort( string *, string *,
int (*)( const string &, const string & ) );
Два этих объявления sort() эквивалентны.
Заметим, что, помимо использования в качестве параметра, указатель на функцию может быть еще и типом возвращаемого значения. Например:
int (*ff( int ))( int*, int );
ff() объявляется как функция, имеющая один параметр типа int и возвращающая указатель на функцию типа
int (*)( int*, int );
И здесь использование директивы typedef делает объявление понятнее. Объявив PF с помощью typedef, мы видим, что ff() возвращает указатель на функцию:
// Использование директивы typedef делает
// объявления более понятными
typedef int (*PF)( int*, int );
PF ff( int );
Типом возвращаемого значения функции не может быть тип функции. В этом случае выдается ошибка компиляции. Например, нельзя объявить ff() таким образом:
// typedef представляет собой тип функции
typedef int func( int*, int );
func ff( int ); // ошибка: тип возврата ff() - функция
Параметры-массивы
Массив в С++ никогда не передается по значению, а только как указатель на его первый, точнее нулевой, элемент. Например, объявление
void putValues( int[ 10 ] );
рассматривается компилятором так, как будто оно имеет вид
void putValues( int* );
Размер массива неважен при объявлении параметра. Все три приведенные записи эквивалентны:
// три эквивалентных объявления putValues()
void putValues( int* );
void putValues( int[] );
void putValues( int[ 10 ] );
Передача массивов как указателей имеет следующие особенности:
изменение значения аргумента внутри функции затрагивает сам переданный объект, а не его локальную копию. Если такое поведение нежелательно, программист должен позаботиться о сохранении исходного значения. Можно также при объявлении функции указать, что она не должна изменять значение параметра, объявив этот параметр константой:
void putValues( const int[ 10 ] );
размер массива не является частью типа параметра. Поэтому функция не знает реального размера передаваемого массива. Компилятор тоже не может это проверить. Рассмотрим пример:
void putValues( int[ 10 ] ); // рассматривается как int*
int main() {
int i, j [ 2 ];
putValues( &i ); // правильно: &i is int*;
// однако при выполнении возможна ошибка
putValues( j ); // правильно: j - адрес 0-го элемента - int*;
// однако при выполнении возможна ошибка
При проверке типов параметров компилятор способен распознать, что в обоих случаях тип аргумента int* соответствует объявлению функции. Однако контроль за тем, не является ли аргумент массивом, не производится.
По принятому соглашению C-строка является массивом символов, последний элемент которого равен нулю. Во всех остальных случаях при передаче массива в качестве параметра необходимо указывать его размер. Это относится и к массивам символов, внутри которых встречается 0. Обычно для такого указания используют дополнительный параметр функции. Например:
void putValues( int[], int size );
int main() {
int i, j[ 2 ];
putValues( &i, 1 );
putValues( j, 2 );
return 0;
}
putValues() печатает элементы массива в следующем формате:
( 10 )< 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 >
где 10 – это размер массива. Вот как выглядит реализация putValues(), в которой используется дополнительный параметр:
#include <iostream>
const lineLength =12; // количество элементов в строке
void putValues( int *ia, int sz )
{
cout << "( " << sz << " )< ";
for (int i=0;i<sz; ++i )
{
if ( i % lineLength == 0 && i )
cout << "\n\t"; // строка заполнена
cout << ia[ i ];
// разделитель, печатаемый после каждого элемента,
// кроме последнего
if ( i % lineLength != lineLength-1 &&
i != sz-1 )
cout << ", ";
}
cout << " >\n";
}
Другой способ сообщить функции размер массива-параметра – объявить параметр как ссылку. В этом случае размер становится частью типа, и компилятор может проверить аргумент в полной мере.
// параметр - ссылка на массив из 10 целых
void putValues( int (&arr)[10] );
int main() {
int i, j [ 2 ];
putValues(i); // ошибка:
// аргумент не является массивом из 10 целых
putValues(j); // ошибка:
// аргумент не является массивом из 10 целых
return 0;
}
Поскольку размер массива теперь является частью типа параметра, новая версия putValues() способна работать только с массивами из 10 элементов. Конечно, это ограничивает ее область применения, зато реализация значительно проще:
#include <iostream>
void putValues( int (&ia)[10] )
{
cout << "( 10 )< ";
for ( int 1 =0; i < 10; ++i ) { cout << ia[ i ];
// разделитель, печатаемый после каждого элемента,
// кроме последнего
if ( i != 9 )
cout << ", ";
}
cout << " >\n";
}
Еще один способ получить размер переданного массива в функции – использовать абстрактный контейнерный тип. (Такие типы были представлены в главе 6. В следующем подразделе мы поговорим об этом подробнее.)
Хотя две предыдущих реализации putValues() правильны, они обладают серьезными недостатками. Так, первый вариант работает только с массивами типа int. Для типа double* нужно писать другую функцию, для long* – еще одну и т.д. Второй вариант производит операции только над массивом из 10 элементов типа int. Для обработки массивов разного размера нужны дополнительные функции. Лучшим решением было бы использовать шаблон – функцию, или, скорее, обобщенную реализацию кода целого семейства функций, которые отличаются только типами обрабатываемых данных. Вот как можно сделать из первого варианта putValues() шаблон, способный работать с массивами разных типов и размеров:
template <class Type>
void putValues( Type *ia, int sz )
{
// так же, как и раньше
}
Параметры шаблона заключаются в угловые скобки. Ключевое слово class означает, что идентификатор Type служит именем параметра, при конкретизации шаблона функции putValues() он заменяется на реальный тип – int, double, string и т.д. (В главе 10 мы продолжим разговор о шаблонах функций.)
Параметр может быть многомерным массивом. Для такого параметра должны быть заданы правые границы всех измерений, кроме первого. Например:
putValues( int matrix[][10], int rowSize );
Здесь matrix объявляется как двумерный массив, который содержит десять столбцов и неизвестное число строк. Эквивалентным объявлением для matrix будет:
int (*matrix)[10]
Многомерный массив передается как указатель на его нулевой элемент. В нашем случае тип matrix – указатель на массив из десяти элементов типа int. Как и для одномерного массива, граница первого измерения не учитывается при проверке типов. Если параметры являются многомерными массивами, то контролируются все измерения, кроме первого.
Заметим, что скобки вокруг *matrix необходимы из-за более высокого приоритета операции взятия индекса. Инструкция
int *matrix[10];
объявляет matrix как массив из десяти указателей на int.
Параметры-ссылки
Использование ссылок в качестве параметров модифицирует стандартный механизм передачи по значению. При такой передаче функция манипулирует локальными копиями аргументов. Используя параметры-ссылки, она получает l-значения своих аргументов и может изменять их.
В каких случаях применение параметров-ссылок оправданно? Во-первых, тогда, когда без использования ссылок пришлось бы менять типы параметров на указатели (см. приведенную выше функцию swap()). Во-вторых, при необходимости вернуть из функции несколько значений. В-третьих, для передачи большого объекта типа класса. Рассмотрим два последних случая подробнее.
Как пример функции, использующей параметр-ссылку для возврата дополнительного значения, возьмем look_up(), которая будет искать заданную величину в векторе целых чисел. В случае успеха look_up() вернет итератор, указывающий на найденный элемент, иначе– на элемент, расположенный за конечным. Если величина содержится в векторе несколько раз, итератор будет указывать на первое вхождение. Кроме того, дополнительный параметр-ссылка occurs возвращает количество найденных элементов.
#include <vector>
// параметр-ссылка 'occurs'
// содержит второе возвращаемое значение
vector<int>::const_iterator look_up(
const vector<int> &vec,
int value, // искомое значение
int &occurs ) // количество вхождений
{
// res_iter инициализируется значением
// следующего за конечным элемента
vector<int>::const_iterator res_iter = vec.end();
occurs = 0;
for ( vector<int>::const_iterator iter = vec.begin();
iter != vec.end();
++iter )
if ( *iter == value )
{
if ( res_iter == vec.end() )
res_iter = iter;
++occurs;
}
return res_iter;
}
Третий случай, когда использование параметра-ссылки может быть полезно, – это большой объект типа класса в качестве аргумента. При передаче по значению объект будет копироваться целиком при каждом вызове функции, что для больших объектов может привести к потере эффективности. Используя параметр-ссылку, функция получает доступ к той области памяти, где размещен сам объект, без создания дополнительной копии. Например:
class Huge { public: double stuff[1000]; };
extern int calc( const Huge & );
int main() {
Huge table[ 1000 ];
// ... инициализация table
int sum = 0;
for ( int ix=0; ix < 1000; ++ix )
// calc() ссылается на элемент массива
// типа Huge
sum += calc( tab1e[ix] );
// ...
}
Может возникнуть желание использовать параметр-ссылку, чтобы избежать создания копии большого объекта, но в то же время не дать вызываемой функции возможности изменять значение аргумента. Если параметр-ссылка не должен модифицироваться внутри функции, то стоит объявить его как ссылку на константу. В такой ситуации компилятор способен распознать и пресечь попытку непреднамеренного изменения значения аргумента.
В следующем примере нарушается константность параметра xx функции foo(). Поскольку параметр функции foo_bar() не является ссылкой на константу, то нет гарантии, что вызов foo_bar() не изменит значения аргумента. Компилятор сигнализирует об ошибке:
class X;
extern int foo_bar( X& );
int foo( const X& xx ) {
// ошибка: константа передается
// функции с параметром неконстантного типа
return foo_bar( xx );
}
Для того чтобы программа компилировалась, мы должны изменить тип параметра foo_bar(). Подойдет любой из следующих двух вариантов:
extern int foo_bar( const X& );
extern int foo_bar( X ); // передача по значению
Вместо этого можно передать копию xx, которую позволено менять:
int foo( const X &xx ) {
// ...
X x2 = xx; // создать копию значения
// foo_bar() может поменять x2,
// xx останется нетронутым
return foo_bar( x2 ); // правильно
}
Параметр-ссылка может именовать любой встроенный тип данных. В частности, разрешается объявить параметр как ссылку на указатель, если программист хочет изменить значение самого указателя, а не объекта, который он адресует. Вот пример функции, обменивающей друг с другом значения двух указателей:
void ptrswap( int *&vl, int *&v2 ) {
int *trnp = v2;
v2 = vl;
vl = tmp;
}
Объявление
int *&v1;
должно читаться справа налево: v1 является ссылкой на указатель на объект типа int. Модифицируем функцию main(), которая вызывала rswap(), для проверки работы ptrswap():
#include <iostream>
void ptrswap( int *&vl, int *&v2 );
int main() {
int i = 10;
int j = 20;
int *pi = &i;
int *pj = &j;
cout << "Перед ptrswap():\tpi: "
<< *pi << "\tpj: " << *pj << endl;
ptrswap( pi, pj );
cout << "После ptrswap():\tpi: "
<< *pi << "\tpj: " << pj << endl;
return 0;
}
Вот результат работы программы:
Перед ptrswap(): pi: 10 pj: 20
После ptrswap(): pi: 20 pj: 10
Параметры-ссылки и параметры-указатели
Когда же лучше использовать параметры-ссылки, а когда – параметры-указатели? В конце концов, и те и другие позволяют функции модифицировать объекты, эффективно передавать в функцию большие объекты типа класса. Что выбрать: объявить параметр ссылкой или указателем?
Как было сказано в разделе 3.6, ссылка может быть один раз инициализирована значением объекта, и впоследствии изменить ее нельзя. Указатель же в течение своей жизни способен адресовать разные объекты или не адресовать вообще.
Поскольку указатель может содержать, а может и не содержать адрес какого-либо объекта, перед его использованием функция должна проверить, не равен ли он нулю:
class X;
void manip( X *px )
{
// проверим на 0 перед использованием
if ( px != 0 )
// обратимся к объекту по адресу...
}
Параметр-ссылка не нуждается в этой проверке, так как всегда существует именуемый ею объект. Например:
class Type { };
void operate( const Type& p1, const Type& p2 );
int main() {
Type obj1;
// присвоим objl некоторое значение
// ошибка: ссылка не может быть равной 0
Type obj2 = operate( objl, 0 );
}
Если параметр должен ссылаться на разные объекты во время выполнения функции или принимать нулевое значение (ни на что не ссылаться), нам следует использовать указатель.
Одна из важнейших сфер применения параметров-ссылок – эффективная реализация перегруженных операций. При этом использование операций остается простым и интуитивно понятным. (Подробнее данный вопрос рассматривается в главе 15.) Разберем маленький пример. Представим себе класс Matrix (матрица). Хорошо бы реализовать операции сложения и присваивания “привычным” способом:
Matrix a, b, c;
c = a + b;
Эти операции реализуются с помощью перегруженных операторов – функций с немного необычным именем. Для оператора сложения такая функция будет называться operator+. Посмотрим, как ее определить:
Matrix // тип возврата - Matrix
operator+( // имя перегруженного оператора
Matrix m1, // тип левого операнда
Matrix m2 // тип правого операнда
)
{
Matrix result;
// необходимые действия
return result;
}
При такой реализации сложение двух объектов типа Matrix выглядит вполне привычно:
a + b;
но, к сожалению, оказывается совершенно неэффективным. Заметим, что параметры у нас передаются по значению. Содержимое двух матриц будет копироваться в область активации функции operator+(), а поскольку объекты типа Matrix весьма велики, затраты времени и памяти на создание копий могут быть совершенно неприемлемыми.
Представим себе, что мы решили использовать указатели в качестве параметров, чтобы избежать этих затрат. Вот модифицированный код operator+():
// реализация с параметрами-указателями
operator+( Matrix *ml, Matrix *m2 )
{
Matrix result;
// необходимые действия
return result;
}
Да, мы добились эффективной реализации, но зато теперь применение нашей операции вряд ли можно назвать интуитивно понятным. В качестве значений параметров-указателей требуется передавать адреса складываемых объектов. Поэтому для сложения двух матриц пришлось бы написать:
&a + &b; // допустимо, хотя и плохо
Хотя такая форма не может не вызвать критику, но все-таки два объекта сложить еще удается. А вот три уже крайне затруднительно:
// а вот это не работает
// &a + &b возвращает объект типа Matrix
&a + &b + &c;
Для того чтобы сложить три объекта, при подобной реализации нужно написать так:
// правильно: работает, однако ...
&( &a + &b ) + &c;
Трудно ожидать, что кто-нибудь согласится писать такие выражения. К счастью, параметры-ссылки дают именно то решение, которое требуется. Если параметр объявлен как ссылка, функция получает его l-значение, а не копию. Лишнее копирование исключается. И тип фактического аргумента может быть Matrix – это упрощает операцию сложения, как и для встроенных типов. Вот схема перегруженного оператора сложения для класса Matrix:
// реализация с параметрами-ссылками
operator+( const Matrix &m1, const Matrix &m2 )
{
Matrix result;
// необходимые действия
return result;
}
При такой реализации сложение трех объектов Matrix выглядит вполне привычно:
a + b + c;
Ссылки были введены в С++ именно для того, чтобы удовлетворить двум требованиям: эффективная реализация и интуитивно понятное применение.
Перечисления
Нередко приходится определять переменную, которая принимает значения из некоего набора. Скажем, файл открывают в любом из трех режимов: для чтения, для записи, для добавления.
Конечно, можно определить три константы для обозначения этих режимов:
const int input = 1;
const int output = 2;
const int append = 3;
и пользоваться этими константами:
bool open_file( string file_name, int open_mode);
// ...
open_file( "Phoenix_and_the_Crane", append );
Подобное решение допустимо, но не вполне приемлемо, поскольку мы не можем гарантировать, что аргумент, передаваемый в функцию open_file() равен только 1, 2 или 3.
Использование перечислимого типа решает данную проблему. Когда мы пишем:
enum open_modes{ input = 1, output, append };
мы определяем новый тип open_modes. Допустимые значения для объекта этого типа ограничены набором 1, 2 и 3, причем каждое из указанных значений имеет мнемоническое имя. Мы можем использовать имя этого нового типа для определения как объекта данного типа, так и типа формальных параметров функции:
void open_file( string file_name, open_modes om );
input, output и append являются элементами перечисления. Набор элементов перечисления задает допустимое множество значений для объекта данного типа. Переменная типа open_modes (в нашем примере) инициализируется одним из этих значений, ей также может быть присвоено любое из них. Например:
open_file( "Phoenix and the Crane", append );
Попытка присвоить переменной данного типа значение, отличное от одного из элементов перечисления (или передать его параметром в функцию), вызовет ошибку компиляции. Даже если попробовать передать целое значение, соответствующее одному из элементов перечисления, мы все равно получим ошибку:
// ошибка: 1 не является элементом перечисления open_modes
open_file( "Jonah", 1 );
Есть способ определить переменную типа open_modes, присвоить ей значение одного из элементов перечисления и передать параметром в функцию:
open_modes om = input;
// ...
om = append;
open_file( "TailTell", om );
Однако получить имена таких элементов невозможно. Если мы напишем оператор вывода:
cout << input << " " << om << endl;
то все равно получим:
1 3
Эта проблема решается, если определить строковый массив, в котором элемент с индексом, равным значению элемента перечисления, будет содержать его имя. Имея такой массив, мы сможем написать:
cout << open_modes_table[ input ] << " "
<< open_modes_table[ om ] << endl
Будет выведено:
input append
Кроме того, нельзя перебрать все значения перечисления:
// не поддерживается
for ( open_modes iter = input; iter != append; ++inter )
// ...
Для определения перечисления служит ключевое слово enum, а имена элементов задаются в фигурных скобках, через запятую. По умолчанию первый из них равен 0, следующий – 1 и так далее. С помощью оператора присваивания это правило можно изменить. При этом каждый следующий элемент без явно указанного значения будет на 1 больше, чем элемент, идущий перед ним в списке. В нашем примере мы явно указали значение 1 для input, при этом output и append будут равны 2 и 3. Вот еще один пример:
// shape == 0, sphere == 1, cylinder == 2, polygon == 3
enum Forms{ share, spere, cylinder, polygon };
Целые значения, соответствующие разным элементам одного перечисления, не обязаны отличаться. Например:
// point2d == 2, point2w == 3, point3d == 3, point3w == 4
enum Points { point2d=2, point2w, point3d=3, point3w=4 };
Объект, тип которого – перечисление, можно определять, использовать в выражениях и передавать в функцию как аргумент. Подобный объект инициализируется только значением одного из элементов перечисления, и только такое значение ему присваивается – явно или как значение другого объекта того же типа. Даже соответствующие допустимым элементам перечисления целые значения не могут быть ему присвоены:
void mumble() {
Points pt3d = point3d; // правильно: pt2d == 3
// ошибка: pt3w инициализируется типом int
Points pt3w = 3;
// ошибка: polygon не входит в перечисление Points
pt3w = polygon;
// правильно: оба объекта типа Points
pt3w = pt3d;
}
Однако в арифметических выражениях перечисление может быть автоматически преобразовано в тип int. Например:
const int array_size = 1024;
// правильно: pt2w преобразуется int
int chunk_size = array_size * pt2w;
Передача аргументов
Функции используют память из стека программы. Некоторая область стека отводится функции и остается связанной с ней до окончания ее работы, по завершении которой отведенная ей память освобождается и может быть занята другой функцией. Иногда эту часть стека называют областью активации.
Каждому параметру функции отводится место в данной области, причем его размер определяется типом параметра. При вызове функции память инициализируется значениями фактических аргументов.
Стандартным способом передачи аргументов является копирование их значений, т.е. передача по значению. При этом способе функция не получает доступа к реальным объектам, являющихся ее аргументами. Вместо этого она получает в стеке локальные копии этих объектов. Изменение значений копий никак не отражается на значениях самих объектов. Локальные копии теряются при выходе из функции.
Значения аргументов при передаче по значению не меняются. Следовательно, программист не должен заботиться о сохранении и восстановлении их значений при вызове функции. Без этого механизма любой вызов мог бы привести к нежелательному изменению аргументов, не объявленных константными явно. Передача по значению освобождает человека от лишних забот в наиболее типичной ситуации.
Однако такой способ передачи аргументов может не устраивать нас в следующих случаях:
передача большого объекта типа класса. Временные и пространственные расходы на размещение и копирование такого объекта могут оказаться неприемлемыми для реальной программы;
иногда значения аргументов должны быть модифицированы внутри функции. Например, swap() должна обменять значения своих аргументов, что невозможно при передаче по значению:
// swap() не меняет значений своих аргументов!
void swap( int vl, int v2 ) {
int tmp = v2;
v2 = vl;
vl = tmp;
}
swap() обменивает значения локальных копий своих аргументов. Те же переменные, что были использованы в качестве аргументов при вызове, остаются неизменными. Это можно проиллюстрировать, написав небольшую программу:
#include <iostream>
void swap( int, int );
int main() {
int i = 10;
int j = 20;
cout << "Перед swap():\ti: "
<< i << "\tj: " << j << endl;
swap( i, j );
cout << "После swap():\ti: "
<< i << "\tj: " << j << endl;
return 0;
}
Результат выполнения программы:
Перед swap(): i: 10 j: 20
После swap(): i: 10 j: 20
Достичь желаемого можно двумя способами. Первый – объявление параметров указателями. Вот как будет выглядеть реализация swap() в этом случае:
// pswap() обменивает значения объектов,
// адресуемых указателями vl и v2
void pswap( int *vl, int *v2 ) {
int tmp = *v2;
*v2 = *vl;
*vl = tmp;
}
Функция main() тоже нуждается в модификации. Вместо передачи самих объектов необходимо передавать их адреса:
pswap( &i, &j );
Теперь программа работает правильно:
Перед swap(): i: 10 j: 20
После swap(): i: 20 j: 10
Альтернативой может стать объявление параметров ссылками. В данном случае реализация swap() выглядит так:
// rswap() обменивает значения объектов,
// на которые ссылаются vl и v2
void rswap( int &vl, int &v2 ) {
int tmp = v2;
v2 = vl;
vl = tmp;
}
Вызов этой функции из main() аналогичен вызову первоначальной функции swap():
rswap( i, j );
Выполнив программу main(), мы снова получим верный результат.
Передача данных через параметры и через глобальные объекты
Различные функции программы могут общаться между собой с помощью двух механизмов. (Под словом “общаться” мы подразумеваем обмен данными.) В одном случае используются глобальные объекты, в другом – передача параметров и возврат значений.
Глобальный объект определен вне функции. Например:
int glob;
int main() {
// что угодно
}
Объект glob является глобальным. (В главе 8 рассмотрение глобальных объектов и глобальной области видимости будет продолжено.) Главное достоинство и одновременно один из наиболее заметных недостатков такого объекта – доступность из любого места программы, поэтому его обычно используют для общения между разными модулями. Обратная сторона медали такова:
функции, использующие глобальные объекты, зависят от этих объектов и их типов. Использовать такую функцию в другом контексте затруднительно;
при модификации такой программы повышается вероятность ошибок. Даже для внесения локальных изменений необходимо понимание всей программы в целом;
если глобальный объект получает неверное значение, ошибку нужно искать по всей программе. Отсутствует локализация;
используя глобальные объекты, труднее писать рекурсивные функции (Рекурсия возникает тогда, когда функция вызывает сама себя. Мы рассмотрим это в разделе 7.5.);
если используются потоки (threads), то для синхронизации доступа к глобальным объектам требуется писать дополнительный код. Отсутствие синхронизации – одна из распространенных ошибок при использовании потоков. (Пример использования потоков при программировании на С++ см. в статье “Distributing Object Computing in C++” (Steve Vinoski and Doug Schmidt) в [LIPPMAN96b].)
Можно сделать вывод, что для передачи информации между функциями предпочтительнее пользоваться параметрами и возвращаемыми значениями.
Вероятность ошибок при таком подходе возрастает с увеличением списка. Считается, что восемь параметров – это приемлемый максимум. В качестве альтернативы длинному списку можно использовать в качестве параметра класс, массив или контейнер. Он способен содержать группу значений.
Аналогично программа может возвращать только одно значение. Если же логика требует нескольких, некоторые параметры объявляются ссылками, чтобы функция могла непосредственно модифицировать значения соответствующих фактических аргументов и использовать эти параметры для возврата дополнительных значений, либо некоторый класс или контейнер, содержащий группу значений, объявляется типом, возвращаемым функцией.
Упражнение 7.9
Каковы две формы инструкции return? Объясните, в каких случаях следует использовать первую, а в каких вторую форму.
Упражнение 7.10
Найдите в данной функции потенциальную ошибку времени выполнения:
vector<string> &readText( ) {
vector<string> text;
string word;
while ( cin >> word ) {
text.push_back( word );
// ...
}
// ....
return text;
}
Упражнение 7.11
Каким способом вы вернули бы из функции несколько значений? Опишите достоинства и недостатки вашего подхода.
Перегруженные функции
Итак, мы уже знаем, как объявлять, определять и использовать функции в программах. В этой главе речь пойдет об их специальном виде– перегруженных функциях. Две функции называются перегруженными, если они имеют одинаковое имя, объявлены в одной и той же области видимости, но имеют разные списки формальных параметров. Мы расскажем, как объявляются такие функции и почему они полезны. Затем мы рассмотрим вопрос об их разрешении, т.е. о том, какая именно из нескольких перегруженных функций вызывается во время выполнения программы. Эта проблема является одной из наиболее сложных в C++. Тем, кто хочет разобраться в деталях, будет интересно прочитать два раздела в конце главы, где тема преобразования типов аргументов и разрешения перегруженных функций раскрывается более подробно.
Перегруженные операторы и определенные пользователем преобразования
В главе 15 мы рассмотрим два вида специальных функций: перегруженные операторы и определенные пользователем преобразования. Они дают возможность употреблять объекты классов в выражениях так же интуитивно, как и объекты встроенных типов. В этой главе мы сначала изложим общие концепции проектирования перегруженных операторов. Затем представим понятие друзей класса со специальными правами доступа и обсудим, зачем они применяются, обратив особое внимание на то, как реализуются некоторые перегруженные операторы: присваивание, взятие индекса, вызов, стрелка для доступа к члену класса, инкремент и декремент, а также специализированные для класса операторы new и delete. Другая категория специальных функций, которая рассматривается в этой главе, – это функции преобразования членов (конвертеры), составляющие набор стандартных преобразований для типа класса. Они неявно применяются компилятором, когда объекты классов используются в качестве фактических аргументов функции или операндов встроенных или перегруженных операторов. Завершается глава развернутым изложением правил разрешения перегрузки функций с учетом передачи объектов в качестве аргументов, функций-членов класса и перегруженных операторов.
Перегрузка и область видимости *
Все перегруженные функции объявляются в одной и той же области видимости. К примеру, локально объявленная функция не перегружает, а просто скрывает глобальную:
#include <string>
void print( const string & );
void print( double ); // перегружает print()
void fooBar( int ival )
{
// отдельная область видимости: скрывает обе реализации print()
extern void print( int );
// ошибка: print( const string & ) не видна в этой области
print( "Value: ");
print( ival ); // правильно: print( int ) видна
}
Поскольку каждый класс определяет собственную область видимости, функции, являющиеся членами двух разных классов, не перегружают друг друга. (Функции-члены класса описываются в главе 13. Разрешение перегрузки для функций-членов класса рассматривается в главе 15.)
Объявлять такие функции разрешается и внутри пространства имен. С каждым из них также связана отдельная область видимости, так что функции, объявленные в разных пространствах, не перегружают друг друга. Например:
#include <string>
namespace IBM {
extern void print( const string & );
extern void print( double ); // перегружает print()
}
namespace Disney {
// отдельная область видимости:
// не перегружает функцию print() из пространства имен IBM
extern void print( int );
}
Использование using-объявлений и using-директив помогает сделать члены пространства имен доступными в других областях видимости. Эти механизмы оказывают определенное влияние на объявления перегруженных функций. (Using-объявления и using-директивы рассматривались в разделе 8.6.)
Каким образом using-объявление сказывается на перегрузке функций? Напомним, что оно вводит псевдоним для члена пространства имен в ту область видимости, в которой это объявление встречается. Что делают такие объявления в следующей программе?
namespace libs_R_us {
int max( int, int );
int max( double, double );
extern void print( int );
extern void print( double );
}
// using-объявления
using libs_R_us::max;
using libs_R_us::print( double ); // ошибка
void func()
{
max( 87, 65 ); // вызывает libs_R_us::max( int, int )
max( 35.5, 76.6 ); // вызывает libs_R_us::max( double, double )
Первое using-объявление вводит обе функции libs_R_us::max в глобальную область видимости. Теперь любую из функций max() можно вызвать внутри func(). По типам аргументов определяется, какую именно функцию вызывать. Второе using-объявление – это ошибка: в нем нельзя задавать список параметров. Функция libs_R_us::print() объявляется только так:
using libs_R_us::print;
Using-объявление всегда делает доступными все перегруженные функции с указанным именем. Такое ограничение гарантирует, что интерфейс пространства имен libs_R_us не будет нарушен. Ясно, что в случае вызова
print( 88 );
автор пространства имен ожидает, что будет вызвана функция libs_R_us::print(int). Если разрешить пользователю избирательно включать в область видимости лишь одну из нескольких перегруженных функций, то поведение программы становится непредсказуемым.
Что происходит, если using-объявление вводит в область видимости функцию с уже существующим именем? Эти функции выглядят так, как будто они объявлены прямо в том месте, где встречается using-объявление. Поэтому введенные функции участвуют в процессе разрешения имен всех перегруженных функций, присутствующих в данной области видимости:
#include <string>
namespace libs_R_us {
extern void print( int );
extern void print( double );
}
extern void print( const string & );
// libs_R_us::print( int ) и libs_R_us::print( double )
// перегружают print( const string & )
using libs_R_us::print;
void fooBar( int ival )
{
print( "Value: "); // вызывает глобальную функцию
// print( const string & )
print( ival ); // вызывает libs_R_us::print( int )
}
Using-объявление добавляет в глобальную область видимости два объявления: для print(int) и для print(double). Они являются псевдонимами в пространстве libs_R_us и включаются в множество перегруженных функций с именем print, где уже находится глобальная print(const string &). При разрешении перегрузки print в fooBar рассматриваются все три функции.
Если using-объявление вводит некоторую функцию в область видимости, в которой уже имеется функция с таким же именем и таким же списком параметров, это считается ошибкой. С помощью using-объявления нельзя задать псевдоним для функции print(int) в пространстве имен libs_R_us, если в глобальной области видимости уже есть print(int). Например:
namespace libs_R_us {
void print( int );
void print( double );
}
void print( int );
using libs_R_us::print; // ошибка: повторное объявление print(int)
void fooBar( int ival )
{
print( ival ); // какая print? ::print или libs_R_us::print
}
Мы показали, как связаны using-объявления и перегруженные функции. Теперь рассмотрим особенности применения using-директивы. Using-директива приводит к тому, что члены пространства имен выглядят объявленными вне этого пространства, добавляя их в новую область видимости. Если в этой области уже есть функция с тем же именем, то происходит перегрузка. Например:
#include <string>
namespace libs_R_us {
extern void print( int );
extern void print( double );
}
extern void print( const string & );
// using-директива
// print(int), print(double) и print(const string &) - элементы
// одного и того же множества перегруженных функций
using namespace libs_R_us;
void fooBar( int ival )
{
print( "Value: "); // вызывает глобальную функцию
// print( const string & )
print( ival ); // вызывает libs_R_us::print( int )
}
Это верно и в том случае, когда есть несколько using-директив. Одноименные функции, являющиеся членами разных пространств, включаются в одно и то множество:
namespace IBM {
int print( int );
}
namespace Disney {
double print( double );
}
// using-директива
// формируется множество перегруженных функций из различных
// пространств имен
using namespace IBM;
using namespace Disney;
long double print(long double);
int main() {
print(1); // вызывается IBM::print(int)
print(3.1); // вызывается Disney::print(double)
return 0;
}
Множество перегруженных функций с именем print в глобальной области видимости включает функции print(int), print(double) и print(long double). Все они рассматриваются в main() при разрешении перегрузки, хотя первоначально были определены в разных пространствах имен.
Итак, повторим, что перегруженные функции находятся в одной и той же области видимости. В частности, они оказываются там в результате применения using-объявлений и using-директив, делающих доступными имена из других областей.
Перегрузка оператора ввода
Перегрузка оператора ввода (>>) похожа на перегрузку оператора вывода, но, к сожалению, возможностей для ошибок гораздо больше. Вот, например, его реализация для класса WordCount:
#include <iostream>
#include "WordCount.h"
/* необходимо модифицировать определение класса WordCount, чтобы
оператор ввода был другом
class WordCount {
friend ostream& operator<<( ostream&, const WordCount& );
friend istream& operator>>( istream&, const WordCount& );
*/
istream&
operator >>( istream &is, WordCount &wd )
{
/* формат хранения объекта WordCount:
* <2> строка
* <7,3> <12,36>
*/
int ch;
/* прочитать знак '<'. Если его нет,
* перевести поток в ошибочное состояние и выйти
*/
if ((ch = is.get()) != '<' )
{
// is.setstate( ios_base::badbit );
return is;
}
// прочитать длину
int occurs;
is >> occurs;
// читать до обнаружения >; ошибки не контролируются
while ( is && (ch = is.get()) != '>' ) ;
is >> wd._word;
// прочитать позиции вхождений;
// каждая позиция имеет формат: < строка, колонка >
for ( int ix = 0; ix < occurs; ++ix )
{
int line, col;
// извлечь значения
while (is && (ch = is.get())!= '<' ) ;
is >> line;
while (is && (ch = is.get())!= ',' ) ;
is >> col;
while (is && (ch = is.get())!= '>' ) ;
wd._occurList.push_back( Location( line, col ));
}
return is;
}
На этом примере показан целый ряд проблем, имеющих отношение к возможным ошибочным состояниям входного потока:
поток, чтение из которого невозможно из-за неправильного формата, переводится в состояние fail:
is.setstate( ios_base::failbit );
операции вставки и извлечения из потока, находящегося в ошибочном состоянии, не работают:
while (( ch = is.get() ) != lbrace)
Инструкция зациклится, если объект istream будет находиться в ошибочном состоянии. Поэтому перед каждым обращением к get() проверяется отсутствие ошибки:
// проверить, находится ли поток "is" в "хорошем" состоянии
while ( is && ( ch = is.get() ) != lbrace)
Если объект istream не в “хорошем” состоянии, то его значение будет равно false. (О состояниях потока мы расскажем в разделе 20.7.)
Данная программа считывает объект класса WordCount, сохраненный оператором вывода из предыдущего раздела:
#include <iostream>
#include "WordCount.h"
int main()
{
WordCount readIn;
// operator>>( cin, readIn )
cin >> readIn;
if ( !cin ) {
cerr << "Ошибка ввода WordCount" << endl;
return -1;
}
// operator<<( cout, readIn )
cout << readIn << endl;
}
Выводится следующее:
<10> rosebud
<11,3> <11,8> <14,2> <34,6> <49,7> <67,5>
<81,2> <82,3> <91,4> <97,8>
Упражнение 20.9
Оператор ввода класса WordCount сам читает объекты класса Location. Вынесите этот код в отдельный оператор ввода класса Location.
Упражнение 20.10
Реализуйте оператор ввода для класса Date из упражнения 20.7 в разделе 20.4.
Упражнение 20.11
Реализуйте оператор ввода для класса CheckoutRecord из упражнения 20.8 в разделе 20.4.
Перегрузка оператора вывода
Если мы хотим, чтобы наш тип класса поддерживал операции ввода/вывода, то необходимо перегрузить оба соответствующих оператора. В этом разделе мы рассмотрим, как перегружается оператор вывода. (Перегрузка оператора ввода – тема следующего раздела.) Например, для класса WordCount он выглядит так:
class WordCount {
friend ostream&
operator<<( ostream&, const WordCount& );
public:
WordCount( string word, int cnt=1 );
// ...
private:
string word;
int occurs;
};
ostream&
operator <<( ostream& os, const WordCount& wd )
{ // формат: <счетчик> слово
os << "< " << " > " > "
<< wd.word;
return os;
}
Проектировщик должен решить, следует ли выводить завершающий символ новой строки. Лучше этого не делать: поскольку операторы вывода для встроенных типов такой символ не печатают, пользователь ожидает аналогичного поведения и от операторов в других классах. Определенный нами в классе WordCount оператор вывода можно использовать вместе с любыми другими операторами:
#include <iostream>
#include "WordCount.h"
int main()
{
WordCount wd( "sadness", 12 );
cout << "wd:\n" << wd << endl;
return 0;
}
Программа печатает на терминале строки:
wd:
<12> sadness
Оператор вывода – это бинарный оператор, который возвращает ссылку на объект класса ostream. В общем случае структура определения перегруженного оператора вывода выглядит так:
// структура перегруженного оператора вывода
ostream&
operator <<( ostream& os, const ClassType &object )
{
// произвольный код для подготовки объекта
// фактическое число членов
os << // ...
// возвращается объект ostream
return os;
}
Первый его аргумент – это ссылка на объект ostream, а второй – ссылка (обычно константная) на объект некоторого класса. Возвращается ссылка на ostream. Значением всегда является объект ostream, для которого оператор вызывался.
Поскольку первым аргументом является ссылка, оператор вывода должен быть определен как обычная функция, а не член класса. (Объяснение см. в разделе 15.1.) Если оператору необходим доступ к неоткрытым членам, то следует объявить его другом класса. (О друзьях говорилось в разделе 15.2.)
Пусть Location – это класс, в котором хранятся номера строки и колонки вхождения слова. Вот его определение:
#include <iostream>
class Location {
friend ostream& operator<<( ostream&, const Location& );
private:
short _line;
short _col;
};
ostream& operator <<( ostream& os, const Location& lc )
{
// объект Loc выводится в виде: < 10,37 >
os << "<" << lc._line
<< "," << lc._col << "> ";
return os;
}
Изменим определение класса WordCount, включив в него вектор occurList объектов Location и объект word класса string:
#include <vector>
#include <string>
#include <iostream>
#include "Location.h"
class WordCount {
friend ostream& operator<<( ostream&, const WordCount& );
public:
WordCount() {}
WordCount( const string &word ) : _word( word ) {}
WordCount( const string &word, int ln, int col )
: _word( word ){ insert_location( ln, col ); }
string word() const { return _word; }
int occurs() const { return _occurList.size(); }
void found( int ln, int col )
{ insert_location( ln, col ); }
private:
void insert_location( int ln, int col )
{ _occurList.push_back( Location( ln, col )); }
string _word;
vector< Location > _occurList;
};
В классах string и Location определен оператор вывода operator<<(). Так выглядит измененное определение оператора вывода в WordCount:
ostream&
operator <<( ostream& os, const WordCount& wd )
{
os << "<" << wd._occurList.size() << "> "
<< wd._word << endl;
int cnt = 0, onLine = 6;
vector< Location >::const_iterator first =
wd._occurList.begin();
vector< Location >::const_iterator last =
wd._occurList.end();
for ( ; first != last; ++first )
{
// os << Location
os << *first << " ";
// форматирование: по 6 в строке
if ( ++cnt >= onLine )
{ os << "\n"; cnt = 0; }
}
return os;
}
А вот небольшая программа для тестирования нового определения класса WordCount; позиции вхождений для простоты “зашиты” в код:
int main()
{
WordCount search( "rosebud" );
// для простоты явно введем 8 вхождений
search.found(11,3); search.found(11,8);
search.found(14,2); search.found(34,6);
search.found(49,7); search.found(67,5);
search.found(81,2); search.found(82,3);
search.found(91,4); search.found(97,8);
cout << "Вхождения: " << "\n"
<< search << endl;
return 0;
}
После компиляции и запуска программа выводит следующее:
Вхождения:
<10> rosebud
<11,3> <11,8> <14,2> <34,6> <49,7> <67,5>
<81,2> <82,3> <91,4> <97,8>
Полученный результат сохранен в файле output. Далее мы определим оператор ввода, с помощью которого прочитаем данные из этого файла.
Упражнение 20.7
Дано определение класса Date:
class Date {
public:
// ...
private:
int month, day, year;
};
Напишите перегруженный оператор вывода даты в формате:
(a)
// полное название месяца
September 8th, 1997
(b)
9 / 8 / 97
(c) Какой формат лучше? Объясните.
(d) Должен ли оператор вывода Date быть функцией-другом? Почему?
Упражнение 20.8
Определите оператор вывода для следующего класса CheckoutRecord:
class CheckoutRecord { // запись о выдаче
public:
// ...
private:
double book_id; // идентификатор книги
string title; // название
Date date_borrowed; // дата выдачи
Date date_due; // дата возврата
pair<string,string> borrower; // кому выдана
vector pair<string,string> wait_list; // очередь на книгу
};
Перегрузка операторов
В предыдущих главах мы уже показывали, что перегрузка операторов позволяет программисту вводить собственные версии предопределенных операторов (см. главу 4) для операндов типа классов. Например, в классе String из раздела 3.15 задано много перегруженных операторов. Ниже приведено его определение:
#include <iostream>
class String;
istream& operator>>( istream &, const String & );
ostream& operator<<( ostream &, const String & );
class String {
public:
// набор перегруженных конструкторов
// для автоматической инициализации
String( const char* = 0 );
String( const String & );
// деструктор: автоматическое уничтожение
~String();
// набор перегруженных операторов присваивания
String& operator=( const String & );
String& operator=( const char * );
// перегруженный оператор взятия индекса
char& operator[]( int );
// набор перегруженных операторов равенства
// str1 == str2;
bool operator==( const char * );
bool operator==( const String & );
// функции доступа к членам
int size() { return _size; };
char * c_str() { return _string; }
private:
int _size;
char *_string;
};
В классе String есть три набора перегруженных операторов. Первый – это набор операторов присваивания:
// набор перегруженных операторов присваивания
String& operator=( const String & );
String& operator=( const char * );
Сначала идет копирующий оператор присваивания. (Подробно они обсуждались в разделе 14.7.) Следующий оператор поддерживает присваивание C-строки символов объекту типа String:
String name;
name = "Sherlock"; // использование оператора operator=( char * )
(Операторы присваивания, отличные от копирующих, мы рассмотрим в разделе 15.3.)
Во втором наборе есть всего один оператор – взятия индекса:
// перегруженный оператор взятия индекса
char& operator[]( int );
Он позволяет программе индексировать объекты класса String точно так же, как массивы объектов встроенного типа:
if ( name[0] != 'S' )
cout << "увы, что-то не так\n";
(Детально этот оператор описывается в разделе 15.4.)
В третьем наборе определены перегруженные операторы равенства для объектов класса String. Программа может проверить равенство двух таких объектов или объекта и C-строки:
// набор перегруженных операторов равенства
// str1 == str2;
bool operator==( const char * );
bool operator==( const String & );
Перегруженные операторы позволяют использовать объекты типа класса с операторами, определенными в главе 4, и манипулировать ими так же интуитивно, как объектами встроенных типов. Например, желая определить операцию конкатенации двух объектов класса String, мы могли бы реализовать ее в виде функции-члена concat(). Но почему concat(), а не, скажем, append()? Выбранное нами имя логично и легко запоминается, но пользователь все же может забыть, как мы назвали функцию. Зачастую имя проще запомнить, если определить перегруженный оператор. К примеру, вместо concat() мы назвали бы новую операцию operator+=(). Такой оператор используется следующим образом:
#include "String.h"
int main() {
String name1 "Sherlock";
String name2 "Holmes";
name1 += " ";
name1 += name2;
if (! ( name1 == "Sherlock Holmes" ) )
cout << "конкатенация не сработала\n";
}
Перегруженный оператор объявляется в теле класса точно так же, как обычная функция-член, только его имя состоит из ключевого слова operator, за которым следует один из множества предопределенных в языке C++ операторов (см. табл. 15.1). Так можно объявить operator+=() в классе String:
class String {
public:
// набор перегруженных операторов +=
String& operator+=( const String & );
String& operator+=( const char * );
// ...
private:
// ...
};
и определить его следующим образом:
#include <cstring>
inline String& String::operator+=( const String &rhs )
{
// Если строка, на которую ссылается rhs, непуста
if ( rhs._string )
{
String tmp( *this );
// выделить область памяти, достаточную
// для хранения конкатенированных строк
_size += rhs._size;
delete [] _string;
_string = new char[ _size + 1 ];
// сначала скопировать в выделенную область исходную строку
// затем дописать в конец строку, на которую ссылается rhs
strcpy( _string, tmp._string );
strcpy( _string + tmp._size, rhs._string );
}
return *this;
}
inline String& String::operator+=( const char *s )
{
// Если указатель s ненулевой
if ( s )
{
String tmp( *this );
// выделить область памяти, достаточную
// для хранения конкатенированных строк
_size += strlen( s );
delete [] _string;
_string = new char[ _size + 1 ];
// сначала скопировать в выделенную область исходную строку
// затем дописать в конец C-строку, на которую ссылается s
strcpy( _string, tmp._string );
strcpy( _string + tmp._size, s );
}
return *this;
}
Перегрузка шаблонов функций *
Шаблон функции может быть перегружен. В следующем примере есть три перегруженных объявления для шаблона min():
// определение шаблона класса Array
// (см. раздел 2.4)
template <typename Type>
class Array( /* ... */ };
// три объявления шаблона функции min()
template <typename Type>
Type min( const Array<Type>&, int ); // #1
template <typename Type>
Type min( const Type*, int ); // #2
template <typename Type>
Type min( Type, Type ); // #3
Следующее определение main() иллюстрирует, как могут вызываться три объявленных таким образом функции:
#include <cmath>
int main()
{
Array<int> iA(1024); // конкретизация класса
int ia[1024];
// Type == int; min( const Array<int>&, int )
int ival0 = min( iA, 1024 );
// Type == int; min( const int*, int )
int ival1 = min( ia, 1024 );
// Type == double; min( double, double )
double dval0 = min( sqrt( iA[0] ), sqrt( ia[0] ) );
return 0;
}
Разумеется, тот факт, что три перегруженных шаблона функции успешно объявлены, не означает, что они могут быть также успешно вызваны. Такие шаблоны могут приводить к неоднозначности при вызове конкретизированного шаблона. Например, для следующего определения шаблона min5()
template <typename T>
int min5( T, T ) { /* ... */ }
функция не конкретизируется по шаблону, если min5() вызывается с аргументами разных типов; при этом процесс вывода заканчивается с ошибкой, поскольку из фактических аргументов функции выводятся два разных типа для T.
int i;
unsigned int ui;
// правильно: для T выведен тип int
min5( 1024, i );
// вывод аргументов шаблона заканчивается с ошибкой:
// для T можно вывести два разных типа
min5 ( i, ui );
Для разрешения второго вызова можно было бы перегрузить min5(), допустив два различных типа аргументов:
template <typename T, typename U>
int min5( T, U );
При следующем обращении производится конкретизация этого шаблона функции:
// правильно: int min5( int, usigned int )
min5( i, ui );
К сожалению, теперь стал неоднозначным предыдущий вызов:
// ошибка: неоднозначность: две возможных конкретизации
// из min5( T, T ) и min5( T, U )
min5( 1024, i );
Второе объявление min5() допускает наличие у функции аргументов различных типов, но не требует этого. В нашем случае и T, и U типа int. Оба объявления шаблонов могут быть конкретизированы вызовом, в котором два аргумента функции имеют один и тот же тип. Единственный способ указать, какой шаблон более предпочтителен, устранив тем самым неоднозначность, – явно задать его аргументы. (О явном задании аргументов шаблона см. раздел 10.4.) Например:
// правильно: конкретизация из min5( T, U )
min5<int, int>( 1024, i );
Однако в этом случае мы можем обойтись без перегрузки шаблона функции. Поскольку шаблон min5(T,U) подходит для всех вызовов, для которых подходит min5(T,T), то одного объявления min5(T,U) вполне достаточно, а объявление min5(T,T) можно удалить. Мы уже говорили в главе 9, что, хотя перегрузка допускается, при проектировании таких функций надо быть внимательным и использовать ее только при необходимости. Те же соображения применимы и к определению перегруженных шаблонов.
В некоторых ситуациях неоднозначности при вызове не возникает, хотя по шаблону можно конкретизировать две разных функции. Если имеются следующие два шаблона для функции sum(), то предпочтение будет отдано первому даже тогда, когда конкретизированы могут быть оба:
template <typename Type>
Type sum( Type*, int );
template <typename Type>
Type sum( Type, int );
int ia[1024];
// Type == int ; sum<int>( int*, int ); или
// Type == int*; sum<int*>( int*, int ); ??
int ival1 = sum<int>( ia, 1024 );
Как это ни удивительно, такой вызов не приводит к неоднозначности. Шаблон конкретизируется из первого определения, так как выбирается наиболее специализированное
определение. Поэтому для аргумента Type принимается int, а не int*.
Для того чтобы один шаблон был более специализирован, чем другой, оба они должны иметь одни и те же имя и число параметров, а для параметров разных типов, как, скажем, T* и T в предыдущем примере, параметр в одном шаблоне должен быть способен принять более широкое множество фактических аргументов, чем соответствующий параметр в другом. Например, для шаблона sum(Type*, int) вместо первого формального параметра функции разрешается подставлять только фактические аргументы типа “указатель”. В то же время в шаблоне sum(Type, int) первому формальному параметру могут соответствовать фактические аргументы любого типа. Первый шаблон sum(Type*, int) допускает более узкое множество аргументов, чем второй, т.е. он более специализирован, а следовательно, он и конкретизируется при вызове функции.
Перехват исключений
В языке C++ исключения обрабатываются в предложениях catch. Когда какая-то инструкция внутри try-блока возбуждает исключение, то просматривается список последующих предложений catch в поисках такого, который может его обработать.
Catch-обработчик состоит из трех частей: ключевого слова catch, объявления одного типа или одного объекта, заключенного в круглые скобки (оно называется объявлением исключения), и составной инструкции. Если для обработки исключения выбрано некоторое catch-предложение, то выполняется эта составная инструкция. Рассмотрим catch-обработчики исключений pushOnFull и popOnEmpty в функции main() более подробно:
catch ( pushOnFull ) {
cerr << "trying to push value on a full stack\n";
return errorCode88;
}
catch ( popOnEmpty ) {
cerr << "trying to pop a value on an empty stack\n";
return errorCode89;
}
В обоих catch-обработчиках есть объявление типа класса; в первом это pushOnFull, а во втором– popOnEmpty. Для обработки исключения выбирается тот обработчик, для которого типы в объявлении исключения и в возбужденном исключении совпадают. (В главе 19 мы увидим, что типы не обязаны совпадать точно: обработчик для базового класса подходит и для исключений с производными классами.) Например, когда функция-член pop() класса iStack возбуждает исключение popOnEmpty, то управление попадает во второй обработчик. После вывода сообщения об ошибке в cerr, функция main() возвращает код errorCode89.
А если catch-обработчики не содержат инструкции return, с какого места будет продолжено выполнение программы? После завершения обработчика выполнение возобновляется с инструкции, идущей за последним catch-обработчиком в списке. В нашем примере оно продолжается с инструкции return в функции main(). После того как catch-обработчик popOnEmpty выведет сообщение об ошибке, main() вернет 0.
int main() {
iStack stack( 32 );
try {
stack.display();
for ( int x = 1; ix < 51; ++ix )
{
// то же, что и раньше
}
}
catch ( pushOnFull ) {
cerr << "trying to push value on a full stack\n";
}
catch ( popOnEmpty ) {
cerr << "trying to pop a value on an empty stack\n";
}
// исполнение продолжается отсюда
return 0;
}
Говорят, что механизм обработки исключений в C++ невозвратный: после того как исключение обработано, управление не возобновляется с того места, где оно было возбуждено. В нашем примере управление не возвращается в функцию-член pop(), возбудившую исключение.
Перехват всех исключений
Иногда функции нужно выполнить определенное действие до того, как она завершит обработку исключения, даже несмотря на то, что обработать его она не может. К примеру, функция захватила некоторый ресурс, скажем открыла файл или выделила память из хипа, и этот ресурс необходимо освободить перед выходом:
void manip() {
resource res;
res.lock(); // захват ресурса
// использование ресурса
// действие, в результате которого возбуждено исключение
res.release(); // не выполняется, если возбуждено исключение
}
Если исключение возбуждено, то управление не попадет на инструкцию, где ресурс освобождается. Чтобы освободить ресурс, не пытаясь перехватить все возможные исключения (тем более, что мы не всегда знаем, какие именно исключения могут возникнуть), воспользуемся специальной конструкцией, позволяющей перехватывать любые исключения. Это не что иное, как предложение catch, в котором объявление исключения имеет вид (...) и куда управление попадает при любом исключении. Например:
// управление попадает сюда при любом возбужденном исключении
catch (...) {
// здесь размещаем наш код
}
Конструкция catch(...) используется в сочетании с повторным возбуждением исключения. Захваченный ресурс освобождается внутри составной инструкции в catch-обработчике перед тем, как передать исключение по цепочке вложенных вызовов в результате повторного возбуждения:
void manip() {
resource res;
res.lock();
try {
// использование ресурса
// действие, в результате которого возбуждено исключение
}
catch (...) {
res.release();
throw;
}
res.release(); // не выполняется, если возбуждено исключение
}
Чтобы гарантировать освобождение ресурса в случае, когда выход из manip() происходит в результате исключения, мы освобождаем его внутри catch(...) до того, как исключение будет передано дальше. Можно также управлять захватом и освобождением ресурса путем инкапсуляции в класс всей работы с ним. Тогда захват будет реализован в конструкторе, а освобождение – в автоматически вызываемом деструкторе. (С этим подходом мы познакомимся в главе 19.)
Предложение catch(...) используется самостоятельно или в сочетании с другими catch-обработчиками. В последнем случае следует позаботиться о правильной организации обработчиков, ассоциированных с try-блоком.
Catch-обработчики исследуются по очереди, в том порядке, в котором они записаны. Как только найден подходящий, просмотр прекращается. Следовательно, если предложение catch(...) употребляется вместе с другими catch-обработчиками, то оно должно быть последним в списке, иначе компилятор выдаст сообщение об ошибке:
try {
stack.display();
for ( int ix = 1; ix < 51; ++x )
{
// то же, что и выше
}
}
catch ( pushOnFull ) { }
catch ( popOnEmpty ) { }
catch ( ... ) { } // должно быть последним в списке catch-обработчиков
Упражнение 11.4
Объясните, почему модель обработки исключений в C++ называется невозвратной.
Упражнение 11.5
Даны следующие объявления исключений. Напишите выражения throw, создающие объект-исключение, который может быть перехвачен указанными обработчиками:
(a) class exceptionType { };
catch( exceptionType *pet ) { }
(b) catch(...) { }
(c) enum mathErr { overflow, underflow, zeroDivide };
catch( mathErr &ref ) { }
(d) typedef int EXCPTYPE;
catch( EXCPTYPE ) { }
Упражнение 11.6
Объясните, что происходит во время раскрутки стека.
Упражнение 11.7
Назовите две причины, по которым объявление исключения в предложении catch следует делать ссылкой.
Упражнение 11.8
На основе кода, написанного вами в упражнении 11.3, модифицируйте класс созданного исключения: неправильный индекс, использованный в операторе operator[](), должен сохраняться в объекте-исключении и затем выводиться catch-обработчиком. Измените программу так, чтобы operator[]() возбуждал при ее выполнении исключение.
Переменные
Представим себе, что мы решаем задачу возведения 2 в степень 10. Пишем:
#include <iostream>
int main() {
// a first solution
cout << "2 raised to the power of 10: ";
cout << 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2;
cout << endl;
return 0;
}
Задача решена, хотя нам и пришлось неоднократно проверять, действительно ли 10 раз повторяется литерал 2. Мы не ошиблись в написании этой длинной последовательности двоек, и программа выдала правильный результат – 1024.
Но теперь нас попросили возвести 2 в 17 степень, а потом в 23. Чрезвычайно неудобно каждый раз модифицировать текст программы! И, что еще хуже, очень просто ошибиться, написав лишнюю двойку или пропустив ее... А что делать, если нужно напечатать таблицу степеней двойки от 0 до 15? 16 раз повторить две строки, имеющие общий вид:
cout << "2 в степени X\t";
cout << 2 * ... * 2;
где Х последовательно увеличивается на 1, а вместо отточия подставляется нужное число литералов?
Да, мы справились с задачей. Заказчик вряд ли будет вникать в детали, удовлетворившись полученным результатом. В реальной жизни такой подход достаточно часто срабатывает, более того, бывает оправдан: задача решена далеко не самым изящным способом, зато в желаемый срок. Искать более красивый и грамотный вариант может оказаться непрактичной тратой времени.
В данном случае “метод грубой силы” дает правильный ответ, но как же неприятно и скучно решать задачу подобным образом! Мы точно знаем, какие шаги нужно сделать, но сами эти шаги просты и однообразны.
Привлечение более сложных механизмов для той же задачи, как правило, значительно увеличивает время подготовительного этапа. Кроме того, чем более сложные механизмы применяются, тем больше вероятность ошибок. Но даже несмотря на неизбежные ошибки и неверные ходы, применение “высоких технологий” может принести выигрыш в скорости разработки, не говоря уже о том, что эти технологии значительно расширяют наши возможности. И – что интересно! – сам процесс решения может стать привлекательным.
Вернемся к нашему примеру и попробуем “ технологически усовершенствовать” его реализацию. Мы можем воспользоваться именованным объектом для хранения значения степени, в которую нужно возвести наше число. Кроме того, вместо повторяющейся последовательности литералов применим оператор цикла. Вот как это будет выглядеть:
#include <iostream>
int main()
{
// objects of type int
int value = 2;
int pow = 10;
cout << value << " в степени "
<< pow << ": \t";
int res = 1;
// оператор цикла:
// повторить вычисление res
// до тех пор пока cnt не станет больше pow
for ( int cnt=1; cnt <= pow; ++cnt )
res = res * value;
cout << res << endl;
}
value, pow, res и cnt – это переменные, которые позволяют хранить, модифицировать и извлекать значения. Оператор цикла for повторяет строку вычисления результата pow раз.
Несомненно, мы создали гораздо более гибкую программу. Однако это все еще не функция. Чтобы получить настоящую функцию, которую можно использовать в любой программе для вычисления степени числа, нужно выделить общую часть вычислений, а конкретные значения задать параметрами.
int pow( int val, int exp )
{
for ( int res = 1; exp > 0; --exp )
res = res * val;
return res;
}
Теперь получить любую степень нужного числа не составит никакого труда. Вот как реализуется последняя наша задача – напечатать таблицу степеней двойки от 0 до 15:
#include <iostream>
extern int pow(int,int);
int main()
{
int val = 2;
int exp = 15;
cout << "Степени 2\n";
for ( int cnt=0; cnt <= exp; ++cnt )
cout << cnt << ": "
<< pow( val, cnt ) << endl;
return 0;
}
Конечно, наша функция pow() все еще недостаточно обобщена и недостаточно надежна. Она не может оперировать вещественными числами, неправильно возводит числа в отрицательную степень – всегда возвращает 1. Результат возведения большого числа в большую степень может не поместиться в переменную типа int, и тогда будет возвращено некоторое случайное неправильное значение. Видите, как непросто, оказывается, писать функции, рассчитанные на широкое применение? Гораздо сложнее, чем реализовать конкретный алгоритм, направленный на решение конкретной задачи.
Первый взгляд на ввод/вывод
Частью стандартной библиотеки С++ является библиотека iostream, которая реализована как иерархия классов и обеспечивает базовые возможности ввода/вывода.
Ввод с терминала, называемый стандартным вводом, “привязан” к предопределенному объекту cin. Вывод на терминал, или стандартный вывод, привязан к объекту cout. Третий предопределенный объект, cerr, представляет собой стандартный вывод для ошибок. Обычно он используется для вывода сообщений об ошибках и предупреждений.
Для использования библиотеки ввода/вывода необходимо включить соответствующий заголовочный файл:
#include <iostream>
Чтобы значение поступило в стандартный вывод или в стандартный вывод для ошибок используется оператор <<:
int v1, v2;
// ...
cout << "сумма v1 и v2 = ";
cout << v1 + v2;
cout << "\n";
Последовательность "\n" представляет собой символ перехода на новую строку. Вместо "\n" мы можем использовать предопределенный манипулятор endl.
cout << endl;
Манипулятор endl не просто выводит данные (символ перехода на новую строку), но и производит сброс буфера вывода. (Предопределенные манипуляторы рассматриваются в главе 20.)
Операторы вывода можно сцеплять. Так, три строки в предыдущем примере заменяются одной:
cout << "сумма v1 и v2 = " << v1 + v2 << "\n";
Для чтения значения из стандартного ввода применяется оператор ввода (>>):
string file_name;
// ...
cout << "Введите имя файла: ";
cin >> file_name;
Операторы ввода, как и операторы вывода, можно сцеплять:
string ifile, ofile;
// ...
cout << "Введите имя входного и выходного файлов: ";
cin >> ifile >> ofile;
Каким образом ввести заранее неизвестное число значений? Мы вернемся к этому вопросу в конце раздела 2.2, а пока скажем, что последовательность инструкций
string word;
while ( cin >> word )
// ...
считывает по одному слову из стандартного ввода до тех пор, пока не считаны все слова. Выражение
( cin >> word )
возвращает false, когда достигнут конец файла. (Подробнее об этом – в главе 20.) Вот пример простой законченной программы, считывающей по одному слову из cin и выводящей их в cout:
#include <iostream>
#include <string>
int main ()
{
string word;
while ( cin >> word )
cout << "Прочитано слово: " << word << "\n";
cout << "Все слова прочитаны!";
}
Вот первое предложение из произведения Джеймса Джойса “Пробуждение Финнегана”:
riverrun, past Eve and Adam's
Если запустить приведенную выше программу и набрать с клавиатуры данное предложение, мы увидим на экране терминала следующее:
Прочитано слово: riverrun,
Прочитано слово: past
Прочитано слово: Eve,
Прочитано слово: and
Прочитано слово: Adam's
Все слова прочитаны!
(В главе 6 мы рассмотрим вопрос о том, как убрать знаки препинания из вводимых слов.)
Пять категорий итераторов
Для поддержки полного набора обобщенных алгоритмов стандартная библиотека определяет пять категорий итераторов, положив в основу классификации множество операций. Это итераторы чтения (InputIterator), записи (OutputIterator), однонаправленные (ForwardIterator) и двунаправленные итераторы (BidirectionalIterator), а также итераторы с произвольным доступом (RandomAccessIterators). Ниже приводится краткое обсуждение характеристик каждой категории:
итератор чтения можно использовать для получения элементов из контейнера, но поддержка записи в контейнер не гарантируется. Такой итератор должен обеспечивать следующие операции (итераторы, поддерживающие также дополнительные операции, можно употреблять в качестве итераторов чтения при условии, что они удовлетворяют минимальным требованиям): сравнение двух итераторов на равенство и неравенство, префиксная и постфиксная форма инкремента итератора для адресации следующего элемента (оператор ++), чтение элемента с помощью оператора разыменования (*). Такого уровня поддержки требуют, в частности, алгоритмы find(), accumulate() и equal(). Любому алгоритму, которому необходим итератор чтения, можно передавать также и итераторы категорий, описанных в пунктах 3, 4 и 5;
итератор записи можно представлять себе как противоположный по функциональности итератору чтения. Иными словами, его можно использовать для записи элементов контейнера, но поддержка чтения из контейнера не гарантируется. Такие итераторы обычно применяются в качестве третьего аргумента алгоритма (например, copy()) и указывают на позицию, с которой надо начинать копировать. Любому алгоритму, которому необходим итератор записи, можно передавать также и итераторы других категорий, перечисленных в пунктах 3, 4 и 5;
однонаправленный итератор можно использовать для чтения и записи в контейнер, но только в одном направлении обхода (обход в обоих направлениях поддерживается итераторами следующей категории). К числу обобщенных алгоритмов, требующих как минимум однонаправленного итератора, относятся adjacent_find(), swap_range() и replace(). Конечно, любому алгоритму, которому необходим подобный итератор, можно передавать также и итераторы описанных ниже категорий;
двунаправленный итератор может читать и записывать в контейнер, а также перемещаться по нему в обоих направлениях. Среди обобщенных алгоритмов, требующих как минимум двунаправленного итератора, выделяются place_merge(), next_permutation() и reverse();
итератор с произвольным доступом, помимо всей функциональности, поддерживаемой двунаправленным итератором, обеспечивает доступ к любой позиции внутри контейнера за постоянное время. Подобные итераторы требуются таким обобщенным алгоритмам, как binary_search(), sort_heap() и nth-element().
Упражнение 12.6
Объясните, почему некорректны следующие примеры. Какие ошибки обнаруживаются во время компиляции?
(a) const vector<string> file_names( sa, sa+6 );
vector<string>::iterator it = file_names.begin()+2;
(b) const vector<int> ivec;
fill( ivec.begin(), ivec.end(), ival );
(c) sort( ivec.begin(), ivec.end() );
(d) list<int> ilist( ia, ia+6 );
binary_search( ilist.begin(), ilist.end() );
(e) sort( ivec1.begin(), ivec3.end() );
Упражнение 12.7
Напишите программу, которая читает последовательность целых чисел из стандартного ввода с помощью потокового итератора чтения istream_iterator. Нечетные числа поместите в один файл посредством ostream_iterator, разделяя значения пробелом. Четные числа таким же образом запишите в другой файл, при этом каждое значение должно размещаться в отдельной строке.
Побитовые операторы
Таблица 4.3. Побитовые операторы
| Символ операции | Значение | Использование | |||
| ~ | Побитовое НЕ | ~expr | |||
| << | Сдвиг влево | expr1 << expr2 | |||
| >> | Сдвиг вправо | expr1 >> expr2 | |||
| & | Побитовое И | expr1 & expr2 | |||
| ^ | Побитовое ИСКЛЮЧАЮЩЕЕ ИЛИ | expr1 ^ expr2 | |||
| | | Побитовое ИЛИ | expr1 | expr2 | |||
| &= | Побитовое И с присваиванием | expr1 &= expr2 | |||
| ^= | Побитовое ИСКЛЮЧАЮЩЕЕ ИЛИ с присваиванием | expr1 ^= expr2 | |||
| |= | Побитовое ИЛИ с присваиванием | expr1 |= expr2 | |||
| <<= | Сдвиг влево с присваиванием | expr1 <<= expr2 | |||
| >>= | Сдвиг вправо с присваиванием | expr1 >>= expr2 |
Побитовые операции рассматривают операнды как упорядоченные наборы битов, каждый бит может иметь одно из двух значений – 0 или 1. Такие операции позволяют программисту манипулировать значениями отдельных битов. Объект, содержащий набор битов, иногда называют битовым вектором. Он позволяет компактно хранить набор флагов – переменных, принимающих значение “да” “нет”. Например, компиляторы зачастую помещают в битовые векторы спецификаторы типов, такие, как const и volatile. Библиотека iostream использует эти векторы для хранения состояния формата вывода.
Как мы видели, в С++ существуют два способа работы со строками: использование C-строк и объектов типа string стандартной библиотеки – и два подхода к массивам: массивы встроенного типа и объект vector. При работе с битовыми векторами также можно применять подход, заимствованный из С, – использовать для представления такого вектора объект встроенного целого типа, обычно unsigned int, или класс bitset стандартной библиотеки С++. Этот класс инкапсулирует семантику вектора, предоставляя операции для манипулирования отдельными битами. Кроме того, он позволяет ответить на вопросы типа: есть ли “взведенные” биты (со значением 1) в векторе? Сколько битов “взведено”?
В общем случае предпочтительнее пользоваться классом bitset, однако, понимание работы с битовыми векторами на уровне встроенных типов данных очень полезно. В этом разделе мы рассмотрим применение встроенных типов для представления битовых векторов, а в следующем – класс bitset.
При использовании встроенных типов для представления битовых векторов можно пользоваться как знаковыми, так и беззнаковыми целыми типами, но мы настоятельно советуем пользоваться беззнаковыми: поведение побитовых операторов со знаковыми типами может различаться в разных реализациях компиляторов.
Побитовое НЕ (~) меняет значение каждого бита операнда. Бит, установленный в 1, меняет значение на 0 и наоборот.
Операторы сдвига (<<, >>) сдвигают биты в левом операнде на указанное правым операндом количество позиций. “Выталкиваемые наружу” биты пропадают, освобождающиеся биты (справа для сдвига влево, слева для сдвига вправо) заполняются нулями. Однако нужно иметь в виду, что для сдвига вправо заполнение левых битов нулями гарантируется только для беззнакового операнда, для знакового в некоторых реализациях возможно заполнение значением знакового (самого левого) бита.
Побитовое И (&) применяет операцию И ко всем битам своих операндов. Каждый бит левого операнда сравнивается с битом правого, находящимся в той же позиции. Если оба бита равны 1, то бит в данной позиции получает значение 1, в любом другом случае – 0. (Побитовое И (&) не надо путать с логическим И (&&),но, к сожалению, каждый программист хоть раз в жизни совершал подобную ошибку.)
Побитовое ИСКЛЮЧАЮЩЕЕ ИЛИ (^) сравнивает биты операндов. Соответствующий бит результата равен 1, если операнды различны (один равен 0, а другой 1). Если же оба операнда равны, результата равен 0.
Побитовое ИЛИ (|) применяет операцию логического сложения к каждому биту операндов. Бит в позиции результата получает значение 1, если хотя бы один из соответствующих битов операндов равен 1, и 0, если биты обоих операндов равны 0. (Побитовое ИЛИ не нужно смешивать с логическим ИЛИ.)
Рассмотрим простой пример. Пусть у нас есть класс из 30 студентов. Каждую неделю преподаватель проводит зачет, результат которого – сдал/не сдал. Итоги можно представить в виде битового вектора. (Заметим, что нумерация битов начинается с нуля, первый бит на самом деле является вторым по счету. Однако для удобства мы не будем использовать нулевой бит; таким образом, студенту номер 1 соответствует бит номер 1. В конце концов, наш преподаватель – не специалист в области программирования.)
unsigned int quiz1 = 0;
Нам нужно иметь возможность менять значение каждого бита и проверять это значение. Предположим, студент 27 сдал зачет. Бит 27 необходимо выставить в 1, не меняя значения других битов. Это можно сделать за два шага. Сначала нужно начать с числа, содержащего 1 в 27-м бите и 0 в остальных. Для этого используем операцию сдвига:
1 << 27;
Применив побитовую операцию ИЛИ к переменной quiz1 и нашей константе, получим нужный результат: значение 27-й бита станет равным значение 1, а другие биты останутся неизменными.
quiz1 |= 1<<27;
Теперь представим себе, что преподаватель перепроверил результаты теста и выяснил, что студент 27 зачет не сдал. Теперь нужно присвоить нуль 27-му биту, не трогая остальных. Сначала применим побитовое НЕ к предыдущей константе и получим число, в котором все биты, кроме 27-го, равны 1:
~(1<<27 );
Теперь побитово умножим (И) эту константу на quiz1 и получим нужный результат: 0 в 27-м бите и неизменные значения остальных.
quiz1 &= ~(1<<27);
Как проверить значение того же 27-го бита? Побитовое И дает true, если 27-й бит равен 1, и false, если 0:
bool hasPassed = quiz1 & (1<<27);
При использовании побитовых операций подобным образом очень легко допустить ошибку. Поэтому чаще всего такие операции инкапсулируются в макросы препроцессора или встроенные функции:
inline boo1 bit_on (unsigned int ui, int pos)
{
return u1 & ( 1 << pos );
}
Вот пример использования:
enum students { Danny = 1, Jeffrey, Ethan, Zev, Ebie, // ...
AnnaP = 26, AnnaL = 27 };
const int student_size = 27;
// наш битовый вектор начинается с 1
boo1 has_passed_quiz[ student_size+l ];
for ( int index = 1; index <= student_size; ++-index )
has_passed_quiz[ index ] = bit_on( quiz1, index );
Раз уж мы начали инкапсулировать действия с битовым вектором в функции, следующим шагом нужно создать класс. Стандартная библиотека С++ включает такой класс bitset, его использование описано ниже.
Упражнение 4.12
Даны два целых числа:
unsigned int ui1 = 3, ui2 = 7;
Каков результат следующих выражений?
(a) ui1 & ui2 (c) uil | ui2
(b) ui1 && ui2 (d) uil || ui2
Упражнение 4.13
Используя пример функции bit_on(), создайте функции bit_turn_on() (выставляет бит в 1), bit_turn_off() (сбрасывает бит в 0), flip_bit() (меняет значение на противоположное) и bit_off() (возвращает true, если бит равен 0). Напишите программу, использующую ваши функции.
Упражнение 4.14
В чем недостаток функций из предыдущего упражнения, использующих тип unsigned int? Их реализацию можно улучшить, используя определение типа с помощью typedef или механизм функций-шаблонов. Перепишите функцию bit_on(),применив сначала typedef, а затем механизм шаблонов.
Почленная инициализация *
Инициализация одного объекта класса другим объектом того же класса, как, например:
Account oldAcct( "Anna Livia Plurabelle" );
Account newAcct( oldAcct );
называется почленной инициализацией по умолчанию. По умолчанию – потому, что она производится автоматически, независимо от того, есть явный конструктор или нет. Почленной – потому, что единицей инициализации является отдельный нестатический член, а не побитовая копия всего объекта класса.
Такую инициализацию проще всего представить, если считать, что компилятор создает специальный внутренний копирующий конструктор, где поочередно, в порядке объявления, инициализируются все нестатические члены. Если рассмотреть первое определение нашего класса Account:
class Account {
public:
// ...
private:
char *_name;
unsigned int _acct_nmbr;
double _balance;
};
то можно представить, что копирующий конструктор по умолчанию определен так:
inline Account::
Account( const Account &rhs )
{
_name = rhs._name;
_acct_nmbr = rhs._acct_nmbr;
_balance = rhs._balance;
}
Почленная инициализация одного объекта класса другим встречается в следующих ситуациях:
явная инициализация одного объекта другим:
Account newAcct( oldAcct );
передача объекта класса в качестве аргумента функции:
extern bool cash_on_hand( Account acct );
if ( cash_on_hand( oldAcct ))
// ...
передача объекта класса в качестве возвращаемого функцией значения:
extern Account
consolidate_accts( const vector< Account >& )
{
Account final_acct;
// выполнить финансовую операцию
return final_acct;
}
определение непустого последовательного контейнера:
// вызывается пять копирующих конструкторов класса string
vector< string > svec( 5 );
(В этом примере с помощью конструктора string по умолчанию создается один временный объект, который затем копируется в пять элементов вектора посредством копирующего конструктора string.)
вставка объекта класса в контейнер:
svec.push_back( string( "pooh" ));
Для большинства определений реальных классов почленная инициализация по умолчанию не соответствует семантике класса. Чаще всего это случается, когда его член представляет собой указатель, который адресует освобождаемую деструктором память в хипе, как, например, в нашем Account.
В результате такой инициализации newAcct._name и oldAcct._name указывают на одну и ту же C-строку. Если oldAcct выходит из области видимости и к нему применяется деструктор, то newAcct._name указывает на освобожденную область памяти. С другой стороны, если newAcct модифицирует строку, адресуемую _name, то она изменяется и для oldAcct. Подобные ошибки очень трудно найти.
Одно из решений псевдонимов указателей заключается в том, чтобы выделить область памяти для копии строки и инициализировать newAcct._name адресом этой области. Следовательно, почленную инициализацию по умолчанию для класса Account нужно подавить за счет предоставления явного копирующего конструктора, который реализует правильную семантику инициализации.
Внутренняя семантика класса также может не соответствовать почленной инициализации по умолчанию. Ранее мы уже объясняли, что два разных объекта Account не должны иметь одинаковые номера счетов. Чтобы гарантировать такое поведение, мы должны подавить почленную инициализацию по умолчанию для класса Account. Вот как выглядит копирующий конструктор, решающий обе эти проблемы:
inline Account::
Account( const Account &rhs )
{
// решить проблему псевдонима указателя
_name = new char[ strlen(rhs._name)+1 ];
strcpy( _name, rhs._name );
// решить проблему уникальности номера счета
_acct_nmbr = get_unique_acct_nmbr();
// копирование этого члена и так работает
_balance = rhs._balance;
}
Альтернативой написанию копирующего конструктора является полный запрет почленной инициализации. Это можно сделать следующим образом:
1. Объявить копирующий конструктор закрытым членом. Это предотвратит почленную инициализацию всюду, кроме функций-членов и друзей класса.
2. Запретить почленную инициализацию в функциях-членах и друзьях класса, намеренно не предоставляя определения копирующего конструктора (однако объявить его так, как описано на шаге 1, все равно нужно). Язык не дает нам возможности ограничить доступ к закрытым членам класса со стороны функций-членов и друзей. Но если определение отсутствует, то любая попытка вызвать копирующий конструктор, законная с точки зрения компилятора, приведет к ошибке во время редактирования связей, поскольку не удастся найти определение символа.
Чтобы запретить почленную инициализацию, класс Account можно объявить так:
class Account {
public:
Account();
Account( const char*, double=0.0 );
// ...
private:
Account( const Account& );
// ...
};
Почленная инициализация и присваивание *
При проектировании класса мы должны позаботиться о том, чтобы почленная инициализация (см. раздел 14.6) и почленное присваивание (см. раздел 14.7) были реализованы правильно и эффективно. Рассмотрим связь этих операций с наследованием.
До сих пор мы не занимались явной обработкой почленной инициализации. Посмотрим, что происходит в нашей иерархии классов Query по умолчанию.
В абстрактном базовом классе Query определены три нестатических члена:
class Query {
public: // ...
protected:
int _paren;
set<short> *_solition;
vector<location> _loc;
// ...
};
Член _solution, если он установлен, адресует множество, память для которого выделена в хипе функцией-членом _vec2set(). Деструктор Query применяет к _solution оператор delete.
Класс Query должен предоставлять как явный копирующий конструктор, так и явный копирующий оператор присваивания. (Если вам это непонятно, перечитайте раздел 14.6.) Но сначала посмотрим, как почленное копирование по умолчанию происходит без них.
Производный класс NameQuery содержит объект-член типа string и подобъект базового Query. Если есть объект folk класса NameQuery:
NameQuery folk( "folk" );
то инициализация music с помощью folk
NameQuery music = folk;
осуществляется так:
1. Компилятор проверяет, есть ли в NameQuery явный копирующий конструктор. (Его нет. Поэтому необходимо применить почленную инициализацию по умолчанию.)
2. Далее компилятор проверяет, содержит ли объект NameQuery подобъекты базового класса. (Да, в нем имеется подобъект Query.)
3. Компилятор проверяет, определен ли в классе Query явный копирующий конструктор. (Нет, поэтому компилятор применит почленную инициализацию по умолчанию.)
4. Компилятор проверяет, содержит ли объект Query подобъекты базового класса. (Нет.)
5. Компилятор просматривает все нестатические члены Query в порядке их объявления. (Если некоторый член не является объектом класса, как, например, _paren и _solution, то в объекте music он инициализируется соответствующим членом объекта folk. Если же является, как, скажем, _loc, то к нему рекурсивно применяется шаг 1. В классе vector определен копирующий конструктор, который вызывается для инициализации music._loc с помощью folk._loc.)
6. Далее компилятор рассматривает нестатические члены NameQuery в порядке их объявления и находит объект класса string, где есть явный копирующий конструктор. Он и вызывается для инициализации music._name с помощью folk._name.
Инициализация по умолчанию music с помощью folk завершена. Она хороша во всех отношениях, кроме одного: если разрешить копирование по умолчанию члена _solution, то программа, скорее всего, завершится аварийно. Поэтому вместо такой обработки мы предоставим явный копирующий конструктор класса Query. Можно, например, скопировать все разрешающее множество:
Query::Query( const Query &rhs )
: _loc( rhs._loc ), _paren(rhs._paren)
{
if ( rhs._solution )
{
_solution = new set<short>;
set<short>::iterator
it = rhs._solution->begin(),
end_it = rhs._solution->end();
for ( ; _ir != end_it; ++it )
_solution->insert( *it );
}
else _solution = 0;
}
Однако, поскольку в нашей реализации разрешающее множество вычисляется по мере необходимости, копировать его сразу нет нужды. Назначение нашего копирующего конструктора – предотвратить копирование по умолчанию. Для этого достаточно инициализировать _solution нулем:
Query::Query( const Query &rhs )
: _loc( rhs._loc ),
_paren(rhs._paren), _solution( 0 )
{}
Шаги 1 и 2 инициализации musiс c помощью folk те же, что и раньше. Но на шаге 3 компилятор обнаруживает, что в классе Query есть явный копирующий конструктор и вызывает его. Шаги 4 и 5 пропускаются, а шаг 6 выполняется, как и прежде.
На этот раз почленная инициализация music с помощью folk корректна. Реализовывать явный копирующий конструктор в NameQuery нет необходимости.
Объект производного класса NotQuery содержит подобъект базового Query и член _op типа Query*, который указывает на операнд, размещенный в хипе. Деструктор NotQuery применяет к этому операнду оператор delete.
Для класса NotQuery почленная инициализация по умолчанию члена _op небезопасна, поэтому необходим явный копирующий конструктор. В его реализации используется виртуальная функция clone(), которую мы определили в предыдущем разделе.
inline NotQuery::
NotQuery( const NotQuery &rhs )
// вызывается Query::Query( const Query &rhs )
: Query( rhs )
{ _op = rhs._op->clone(); }
При почленной инициализации одного объекта класса NotQuery другим выполняются два шага:
1. Компилятор проверяет, определен ли в NotQuery явный копирующий конструктор. Да, определен.
2. Этот конструктор вызывается для почленной инициализации.
Вот и все. Ответственность за правильную инициализацию подобъекта базового класса и нестатических членов возлагается на копирующий конструктор NotQuery. (Классы AndQuery и OrQuery сходны с NotQuery, поэтому мы оставляем их в качестве упражнения для читателей.)
Почленное присваивание аналогично почленной инициализации. Если имеется явный копирующий оператор присваивания, то он вызывается для выполнения присваивания одного объекта класса другому. В противном случае применяется почленное присваивание по умолчанию.
Если базовый класс есть, то сначала с помощью копирующего оператора присваивания почленно присваивается подобъект данного класса, иначе такое присваивание рекурсивно применяется к базовым классам и членам подобъекта базового класса.
Просматриваются все нестатические члены в порядке их объявления. Если член не является объектом класса, то его значение справа от знака равенства копируется в значение соответствующего члена слева от знака равенства. Если же член является объектом класса, в котором определен явный копирующий оператор присваивания, то он и вызывается. В противном случае к базовым классам и членам объекта-члена применяется почленное присваивание по умолчанию.
Вот как выглядит копирующий оператор присваивания для нашего объекта Query. Еще раз отметим, что в этом месте необязательно копировать разрешающее множество, достаточно предотвратить копирование по умолчанию:
Query&
Query::
operator=( const Query &rhs )
{
// предотвратить присваивание самому себе
if ( &rhs != this )
{
_paren = rhs._paren;
_loc = rhs._loc;
delete _solution;
_solution = 0;
}
return *this;
};
В классе NameQuery явный копирующий оператор присваивания не нужен. Присваивание одного объекта NameQuery другому выполняется в два шага:
1. Для присваивания подобъектов Query двух объектов NameQuery вызывается явный копирующий оператор присваивания класса Query.
2. Для присваивания членов string вызывается явный копирующий оператор присваивания этого класса.
Для объектов NameQuery вполне достаточно почленного присваивания по умолчанию.
В каждом из классов NotQuery, AndQuery и OrQuery для безопасного копирования операндов требуется явный копирующий оператор присваивания. Вот его реализация для NotQuery:
inline NotQuery&
NotQuery::
operator=( const NotQuery &rhs )
{
// предотвратить присваивание самому себе
if ( &rhs != this )
{
// вызвать копирующий оператор присваивания Query
this->Query::operator=( rhs );
// скопировать операнд
_op = rhs._op->clone();
}
return *this;
}
В отличие от копирующего конструктора, в копирующем операторе присваивания нет специальной части, через которую вызывается аналогичный оператор базового класса. Для этого используются две синтаксических конструкции: явный вызов, продемонстрированный выше, и явное приведение типа, как в следующем примере:
(*static_cast<Query*>(this)) = rhs;
(Реализация копирующих операторов присваивания в классах AndQuery и OrQuery выглядит так же, поэтому мы оставим ее в качестве упражнения.)
Ниже предложена небольшая программа для тестирования данной реализации. Мы создаем или копируем объект, а затем распечатываем его.
#include "Query.h"
int
main()
{
NameQuery nm( "alice" );
NameQuery nm( "emma" );
NotQuery nq1( &nm );
cout << "notQuery 1: " << nq1 << endl;
NotQuery nq2( nq1 );
cout << "notQuery 2: " << nq2 << endl;
NotQuery nq3( &nm2 );
cout << "notQuery 3: " << nq3 << endl;
nq3 = nq2;
cout << "notQuery 3 присвоено значение nq2: " << nq3 << endl;
AndQuery aq( &nq1, &nm2 );
cout << "AndQuery : " << aq << endl;
AndQuery aq2( aq );
cout << "AndQuery 2: " << aq2 << endl;
AndQuery aq3( &nm, &nm2 );
cout << "AndQuery 3: " << aq3 << endl;
aq2 = aq3;
cout << "AndQuery 2 после присваивания: " << aq2 << endl;
}
После компиляции и запуска программа печатает следующее:
notQuery 1: ! alice
notQuery 2: ! alice
notQuery 3: ! emma
notQuery 3 присвоено значение nq2: ! alice
AndQuery : ! alice && emma
AndQuery 2: ! alice && emma
AndQuery 3: alice && emma
AndQuery 2 после присваивания: alice && emma
Упражнение 17.18
Реализуйте копирующие конструкторы в классах AndQuery и OrQuery.
Упражнение 17.19
Реализуйте копирующие операторы присваивания в классах AndQuery и OrQuery.
Упражнение 17.20
Что указывает на необходимость реализации явных копирующего конструктора и копирующего оператора присваивания?
Почленное присваивание *
Присваивание одному объекту класса значения другого объекта того же класса реализуется почленным присваиванием по умолчанию. От почленной инициализации по умолчанию оно отличается только использованием копирующего оператора присваивания вместо копирующего конструктора:
newAcct = oldAcct;
по умолчанию присваивает каждому нестатическому члену newAcct значение соответственного члена oldAcct. Компилятор генерирует следующий копирующий оператор присваивания:
inline Account&
Account::
operator=( const Account &rhs )
{
_name = rhs._name;
_balance = rhs._balance;
_acct_nmbr = rhs._acct_nmbr;
}
Как правило, если для класса не подходит почленная инициализация по умолчанию, то не подходит и почленное присваивание по умолчанию. Например, для первоначального определения класса Account, где член _name был объявлен как char*, такое присваивание не годится ни для _name, ни для _acct_nmbr.
Мы можем подавить его, если предоставим явный копирующий оператор присваивания, где будет реализована подходящая для класса семантика:
// общий вид копирующего оператора присваивания
className&
className::
operator=( const className &rhs )
{
// не надо присваивать самому себе
if ( this != &rhs )
{
// здесь реализуется семантика копирования класса
}
// вернуть объект, которому присвоено значение
return *this;
}
Здесь условная инструкция
if ( this != &rhs )
предотвращает присваивание объекта класса самому себе, что особенно неприятно в ситуации, когда копирующий оператор присваивания сначала освобождает некоторый ресурс, ассоциированный с объектом в левой части, чтобы назначить вместо него ресурс, ассоциированный с объектом в правой части. Рассмотрим копирующий оператор присваивания для класса Account:
Account&
Account::
operator=( const Account &rhs )
{
// не надо присваивать самому себе
if ( this != &rhs )
{
delete [] _name;
_name = new char[strlen(rhs._name)+1];
strcpy( _name,rhs._name );
_balance = rhs._balance;
_acct_nmbr = rhs._acct_nmbr;
}
return *this;
}
Когда один объект класса присваивается другому, как, например, в инструкции:
newAcct = oldAcct;
выполняются следующие шаги:
1. Выясняется, есть ли в классе явный копирующий оператор присваивания.
2. Если есть, проверяются права доступа к нему, чтобы понять, можно ли его вызывать в данном месте программы.
3. Оператор вызывается для выполнения присваивания; если же он недоступен, компилятор выдает сообщение об ошибке.
4. Если явного оператора нет, выполняется почленное присваивание по умолчанию.
5. При почленном присваивании каждому члену встроенного или составного члена объекта в левой части присваивается значение соответственного члена объекта в правой части.
6. Для каждого члена, являющегося объектом класса, рекурсивно применяются шаги 1-6, пока не останутся только члены встроенных и составных типов.
Если мы снова модифицируем определение класса Account так, что _name будет иметь тип string, то почленное присваивание по умолчанию
newAcct = oldAcct;
будет выполняться так же, как при создании компилятором следующего оператора присваивания:
inline Account&
Account::
operator=( const Account &rhs )
{
_balance = rhs._balance;
_acct_nmbr = rhs._acct_nmbr;
// этот вызов правилен и с точки зрения программиста
name.string::operator=( rhs._name );
}
Однако почленное присваивание по умолчанию для объектов класса Account не подходит из-за _acct_nmbr. Нужно реализовать явный копирующий оператор присваивания с учетом того, что _name – это объект класса string:
Account&
Account::
operator=( const Account &rhs )
{
// не надо присваивать самому себе
if ( this != &rhs )
{
// вызывается string::operator=( const string& )
_name = rhs._name;
_balance = rhs._balance;
}
return *this;
}
Чтобы запретить почленное копирование, мы поступаем так же, как и в случае почленной инициализации: объявляем оператор закрытым и не предоставляем его определения.
Копирующий конструктор и копирующий оператор присваивания обычно рассматривают вместе. Если необходим один, то, как правило, необходим и другой. Если запрещается один, то, вероятно, следует запретить и другой.
Упражнение 14.17
Реализуйте копирующий оператор присваивания для каждого из классов, определенных в упражнении 14.14 из раздела 14.6.
Упражнение 14.18
Нужен ли копирующий оператор присваивания для того класса, который вы выбрали в упражнении 14.3 из раздела 14.2? Если да, реализуйте его. В противном случае объясните, почему он не нужен.
Почти виртуальный оператор new
Если дан указатель на один из конкретных подтипов запроса, то разместить в хипе дубликат объекта несложно:
NotQuery *pnq;
// установить pnq ...
// оператор new вызывает
// копирующий конструктор NotQuery ...
NotQuery *pnq2 = new NotQuery( *pnq );
Если же у нас есть только указатель на абстрактный класс Query, то задача создания дубликата становится куда менее тривиальной:
const Query *pq = pnq->op();
// как получить дубликат pq?
Если бы позволялось объявить виртуальный экземпляр оператора new, то проблема была бы решена, поскольку автоматически вызывался бы нужный экземпляр. К сожалению, это невозможно: new – статическая функция-член, которая применяется к неструктурированной памяти еще до конструирования объекта класса (см. раздел 15.8).
Но хотя оператор new нельзя сделать виртуальным, разрешается создать его суррогат, который будет выделять память из хипа и копировать туда объекты, – clone():
class Query {
public:
virtual Query *clone() = 0;
// ...
};
Вот как он может быть реализован в классе NameQuery:
class NameQuery : public Query {
public:
virtual Query *clone()
// вызывается копирующий конструктор класса NameQuery
{ return new NameQuery( *this ); }
// ...
};
Это работает правильно, если тип целевого указателя Query*:
Query *pq = new NameQuery( "valery" );
Query *pq2 = pq->clone();
Если же его тип равен NameQuery*, нужно привести возвращенный указатель типа Query* назад к типу NameQuery*:
NameQuery *pnq = new NameQuery( "Rilke" );
NameQuery *pnq2 =
static_cast<NameQuery*>( pnq->clone() );
(Причина, по которой необходимо преобразование типа, объясняется в разделе 19.1.1.)
Как правило, тип значения, возвращаемого реализацией виртуальной функции в производном классе, должен совпадать с типом, возвращаемым ее реализацией в базовом. Исключение, о котором мы уже упоминали, призвано поддержать рассмотренную ситуацию. Если виртуальная функция в базовом классе возвращает значение некоторого типа класса (либо указатель или ссылку на тип класса), то ее реализация в производном может возвращать значение, тип которого является производным от этого класса с открытым типом наследования (то же относится к ссылкам и указателям):
class NameQuery : public Query {
public:
virtual NameQuery *clone()
{ return new NameQuery( *this ); }
// ...
};
Теперь pq2 и pnq2 можно инициализировать без явного приведения типов:
// Query *pq = new NameQuery( "Broch" );
Query *pq2 = pq->clone(); // правильно
// NameQuery *pnq = new NameQuery( "Rilke" );
NameQuery *pnq2 = pnq->clone(); // правильно
Так выглядит реализация clone() в классе NotQuery:
class NotQuery : public Query {
public:
virtual NotQuery *clone()
{ return new NotQuery( *this ); }
// ...
};
Реализации в AndQuery и OrQuery аналогичны. Чтобы эти реализации clone() работали правильно, в классах NotQuery, AndQuery и OrQuery должны быть явно определены копирующие конструкторы. (Мы займемся этим в разделе 17.6.)
Подробнее о расширении типов
Под расширением типа понимается одно из следующих преобразований:
фактический аргумент типа char, unsigned char или short расширяется до типа int. Фактический аргумент типа unsigned short расширяется до типа int, если машинный размер int больше, чем размер short, и до типа unsigned int в противном случае;
аргумент типа float расширяется до типа double;
аргумент перечислимого типа расширяется до первого из следующих типов, который способен представить все значения элементов перечисления: int, unsigned int, long, unsigned long;
аргумент типа bool расширяется до типа int.
Подобное расширение применяется, когда тип фактического аргумента совпадает с одним из только что перечисленных типов, а формальный параметр относится к соответствующему расширенному типу:
extern void manip( int );
int main() {
manip( 'a' ); // тип char расширяется до int
return 0;
}
Символьный литерал имеет тип char. Он расширяется до int. Поскольку расширенный тип соответствует типу формального параметра функции manip(), мы говорим, что ее вызов требует расширения типа аргумента.
Рассмотрим следующий пример:
extern void print( unsigned int );
extern void print( int );
extern void print( char );
unsigned char uc;
print( uc ); // print( int ); для uc требуется только расширение типа
Для аппаратной платформы, на которой unsigned char занимает один байт памяти, а int – четыре байта, расширение преобразует unsigned char в int, так как с его помощью можно представить все значения типа unsigned char. Для такой машинной архитектуры из приведенного в примере множества перегруженных функций наилучшее соответствие аргументу типа unsigned char обеспечивает print(int). Для двух других функций установление соответствия требует стандартного приведения.
Следующий пример иллюстрирует расширение фактического аргумента перечислимого типа:
enum Stat ( Fail, Pass );
extern void ff( int );
extern void ff( char );
int main() {
// правильно: элемент перечисления Pass расширяется до типа int
ff( Pass ); // ff( int )
ff( 0 ); // ff( int )
}
Иногда расширение перечислений преподносит сюрпризы. Компиляторы часто выбирают представление перечисления в зависимости от значений его элементов. Предположим, что в вышеупомянутой архитектуре (один байт для char и четыре байта для int) определено такое перечисление:
enum e1 { a1, b1, c1 };
Поскольку есть всего три элемента: a1, b1 и c1 со значениями 0, 1 и 2 соответственно – и поскольку все эти значения можно представить типом char, то компилятор, как правило, и выбирает char для представления типа e1. Рассмотрим, однако, перечисление e2 со следующим множеством элементов:
enum e2 { a2, b2, c2=0x80000000 };
Так как одна из констант имеет значение 0x80000000, то компилятор обязан выбрать для представления e2 такой тип, который достаточен для хранения значения 0x80000000, то есть unsigned int.
Итак, хотя и e1, и e2 являются перечислениями, их представления различаются. Из-за этого e1 и e2 расширяются до разных типов:
#include <string>
string format( int );
string format( unsigned int );
int main() {
format(a1); // вызывается format( int )
format(a2); // вызывается format( unsigned int )
return 0;
}
При первом обращении к format() фактический аргумент расширяется до типа int, так как для представления типа e1 используется char, и, следовательно, вызывается перегруженная функция format(int). При втором обращении тип фактического аргумента e2 представлен типом unsigned int и аргумент расширяется до unsigned int, из-за чего вызывается перегруженная функция format(unsigned int). Поэтому следует помнить, что поведение двух перечислений по отношению к процессу разрешения перегрузки может быть различным и зависеть от значений элементов, определяющих, как происходит расширение типа.
