Операция list::unique()

void list::unique(); template <class BinaryPredicate>

   void list::unique( BinaryPredicate pred );

Операция unique()

удаляет соседние дубликаты. По умолчанию при сравнении используется оператор равенства, определенный для типа элементов контейнера. Например, если даны значения {0,2,4,6,4,2,0}, то после применения unique()

список останется таким же, поскольку в соседних позициях дубликатов нет. Но если мы сначала отсортируем список, что даст {0,0,2,2,4,4,6}, а потом применим unique(), то получим четыре различных значения {0,2,4,6}.

ilist.unique();

Вторая форма unique()

принимает альтернативный оператор сравнения. Например,

class EvenPair { public:    bool operator()( int val1, val2 )         { return ! (val2 % val1 );   } };

ilist.unique( EvenPair() );

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

Эти операции, являющиеся членами класса, следует предпочесть соответствующим обобщенным алгоритмам при работе со списками. Остальные обобщенные алгоритмы, такие, как find(), transform(), for_each() и т.д., работают со списками так же эффективно, как и с другими контейнерами (еще раз напомним, что подробно все алгоритмы рассматриваются в Приложении).

Упражнение 12.8

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

Часть IV

Объектное программирование

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

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

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

В главе 15 мы расскажем о перегрузке операторов, которая позволяет использовать операнды типа класса со встроенными операторами, описанными в главе 4. Таким образом, работа с объектами типа класса может быть сделана столь же понятной, как и работа со встроенными типами. В начале главы 15 представлены общие концепции и соображения, касающиеся проектирования перегрузки операторов, а затем рассмотрены конкретные операторы, такие, как присваивание, взятие индекса, вызов, а также специфичные для классов операторы new и delete. Иногда необходимо объявить перегруженный оператор, как друга класса, наделив его специальными правами доступа, в данной главе объясняется, зачем это нужно. Здесь же представлен еще один специальный вид функций-членов – конвертеры, которые позволяют программисту определить стандартные преобразования. Конвертеры неявно применяются компилятором, когда объекты класса используются в качестве фактических аргументов функции или операндов встроенного либо перегруженного оператора. Завершается глава изложением правил разрешения перегрузки функций с учетом аргументов типа класса, функций-членов и перегруженных операторов.

Тема главы 16 – шаблоны классов. Шаблон – это предписание для создания класса, в котором один или несколько типов параметризованы. Например, vector

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

13

Оператор =

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

Для класса могут быть определены и другие операторы присваивания. Если объектам класса надо присваивать значения типа, отличного от этого класса, то разрешается определить такие операторы, принимающие подобные параметры. Например, чтобы поддержать присваивание C-строки объекту String:

String car ("Volks");

car = "Studebaker";

мы предоставляем оператор, принимающий параметр типа const char*. Эта операция уже была объявлена в нашем классе:

class String { public:    // оператор присваивания для char*    String& operator=( const char * );    // ... private:    int  _size;    char *string;

};

Такой оператор реализуется следующим образом. Если объекту String присваивается нулевой указатель, он становится “пустым”. В противном случае ему присваивается копия C-строки:

String& String::operator=( const char *sobj ) {    // sobj - нулевой указатель    if (! sobj ) {       _size = 0;       delete[] _string;       _string = 0;    }    else {       _size = strlen( sobj );       delete[] _string;       _string = new char[ _size + 1 ];       strcpy( _string, sobj );    }    return *this;

}

_string

ссылается на копию той C-строки, на которую указывает sobj. Почему на копию? Потому что непосредственно присвоить sobj

члену _string

нельзя:

_string = sobj;   // ошибка: несоответствие типов

sobj – это указатель на const и, следовательно, не может быть присвоен указателю на “не-const” (см. раздел 3.5). Изменим определение оператора присваивания:

String& String::operator=( const *sobj ) { // ... }

Теперь _string

прямо ссылается на C-строку, адресованную sobj. Однако при этом возникают другие проблемы. Напомним, что C-строка имеет тип const char*. Определение параметра как указателя на не-const делает присваивание невозможным:

car = "Studebaker";  // недопустимо с помощью operator=( char

*) !

Итак, выбора нет. Чтобы присвоить C- строку объекту типа String, параметр должен иметь тип const char*.

Хранение в _string

прямой ссылки на C-строку, адресуемую sobj, порождает и иные сложности. Мы не знаем, на что именно указывает sobj. Это может быть массив символов, который модифицируется способом, неизвестным объекту String. Например:

char ia[] = { 'd', 'a', 'n', 'c', 'e', 'r' }; String trap = ia;   // trap._string ссылается на ia

ia[3] = 'g';  // а вот это нам не нужно:

              // модифицируется и ia, и trap._string

Если trap._string

напрямую ссылался на ia, то объект trap

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

Обратите внимание, что в операторе присваивания используется delete. Член _string

содержит ссылку на массив символов, расположенный в хипе. Чтобы предотвратить утечку, память, выделенная под старую строку, освобождается с помощью delete до выделения памяти под новую. Поскольку _string адресует массив символов, следует использовать версию delete для массивов (см. раздел 8.4).

И последнее замечание об операторе присваивания. Тип возвращаемого им значения – это ссылка на класс String. Почему именно ссылка? Дело в том, что для встроенных типов операторы присваивания можно сцеплять:

// сцепление операторов присваивания int iobj, jobj;

iobj = jobj = 63;

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

iobj = (jobj = 63);

Это удобно и при работе с объектами класса String: поддерживается, к примеру, следующая конструкция:

String ver, noun;

verb = noun = "count";

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

Операторы присваивания бывают перегруженными. Например, в нашем классе String

есть такой набор:

// набор перегруженных операторов присваивания String& operator=( const String & );

String& operator=( const char * );

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

Оператор dynamic_cast

Оператор dynamic_cast

можно применять для преобразования указателя, ссылающегося на объект типа класса в указатель на тип класса из той же иерархии. Его также используют для трансформации l-значения объекта типа класса в ссылку на тип класса из той же иерархии. Приведение типов с помощью оператора dynamic_cast, в отличие от других имеющихся в C++ способов, осуществляется во время выполнения программы. Если указатель или l-значение не могут быть преобразованы в целевой тип, то dynamic_cast

завершается неудачно. В случае приведения типа указателя признаком неудачи служит возврат нулевого значения. Если же l-значение нельзя трансформировать в ссылочный тип, возбуждается исключение. Ниже мы приведем примеры неудачного выполнения

этого оператора.

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

class employee { public:    virtual int salary(); }; class manager : public employee { public:    int salary(); }; class programmer : public employee { public:    int salary(); }; void company::payroll( employee *pe ) {    // используется pe->salary()

}

В компании есть разные категории служащих. Параметром функции-члена payroll()

класса company

является указатель на объект employee, который может адресовать один из типов manager или programmer. Поскольку payroll()

обращается к виртуальной функции-члену salary(), то вызывается подходящая замещающая функция, определенная в классе manager или programmer, в зависимости от того, какой объект адресован указателем.

Допустим, класс employee

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

class employee { public:    virtual int salary();       // çàðïëàòà    virtual int bonus();        // ïðåìèÿ }; class manager : public employee { public:    int salary(); }; class programmer : public employee { public:    int salary();    int bonus(); }; void company::payroll( employee *pe ) {    // èñïîëüçóåòñÿ pe->salary() è pe->bonus()

}

Если параметр pe

функции payroll()

указывает на объект типа manager, то вызывается виртуальная функция-член bonus() из базового класса employee, поскольку в классе manager она не замещена. Если же pe

указывает на объект типа programmer, то вызывается виртуальная функция-член bonus() из класса programmer.

После добавления новых виртуальных функций в иерархию классов придется перекомпилировать все функции-члены. Добавить bonus() можно, если у нас есть доступ к исходным текстам функций-членов в классах employee, manager и programmer. Однако если иерархия была получена от независимого поставщика, то не исключено, что в нашем распоряжении имеются только заголовочные файлы, описывающие интерфейс библиотечных классов и объектные файлы с их реализацией, а исходные тексты функций-членов недоступны. В таком случае перекомпиляция всей иерархии невозможна.

Если мы хотим расширить функциональность библиотеки классов, не добавляя новые виртуальные функции-члены, можно воспользоваться оператором dynamic_cast.

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

class employee { public:    virtual int salary(); }; class manager : public employee { public:    int salary(); }; class programmer : public employee { public:    int salary();    int bonus();

<


};

Напомним, что payroll()

принимает в качестве параметра указатель на базовый класс employee. Мы можем применить оператор dynamic_cast для получения указателя на производный programmer и воспользоваться им для вызова функции-члена bonus():

void company::payroll( employee *pe ) {    programmer *pm = dynamic_cast< programmer* >( pe );    // åñëè pe óêàçûâàåò íà îáúåêò òèïà programmer,    // òî dynamic_cast âûïîëíèòñÿ óñïåøíî è pm áóäåò    // óêàçûâàòü íà íà÷àëî îáúåêòà programmer    if ( pm ) {       // èñïîëüçîâàòü pm äëÿ âûçîâà programmer::bonus()    }    // åñëè pe íå óêàçûâàåò íà îáúåêò òèïà programmer,    // òî dynamic_cast âûïîëíèòñÿ íåóäà÷íî    // è pm áóäåò ñîäåðæàòü 0    else {       // èñïîëüçîâàòü ôóíêöèè-÷ëåíû êëàññà employee    }

}

Оператор

dynamic_cast< programmer* >( pe )



приводит свой операнд pe к типу programmer*. Преобразование будет успешным, если pe ссылается на объект типа programmer, и неудачным в противном случае: тогда результатом dynamic_cast

будет 0.

Таким образом, оператор dynamic_cast

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

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

Если в предыдущем примере pe

действительно указывает на объект типа programmer, то операция dynamic_cast

завершится успешно и pm

будет инициализирован указателем на объект типа programmer. В противном случае pm

получит значение 0. Проверив значение pm, функция company::payroll()

может узнать, указывает ли pm на объект programmer. Если это так, то она вызывает функцию-член programmer::bonus() для вычисления премии программисту. Если же dynamic_cast завершается неудачно, то pe

указывает на объект типа manager, а значит, необходимо применить более общий алгоритм расчета, не использующий новую функцию-член programmer::bonus().

Оператор dynamic_cast

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

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

Одна из возможных ошибок – это работа с результатом dynamic_cast без предварительной проверки на 0: нулевой указатель нельзя использовать для адресации объекта класса. Например:

void company::payroll( employee *pe ) {    programmer *pm = dynamic_cast< programmer* >( pe );    // ïîòåíöèàëüíàÿ îøèáêà: pm èñïîëüçóåòñÿ áåç ïðîâåðêè çíà÷åíèÿ    static int variablePay = 0;    variablePay += pm->bonus();    // ...

}

Результат, возвращенный dynamic_cast, всегда следует проверять, прежде чем использовать в качестве указателя. Более правильное определение функции company::payroll()

могло бы выглядеть так:

void company::payroll( employee *pe ) {    // âûïîëíèòü dynamic_cast è ïðîâåðèòü ðåçóëüòàò    if ( programmer *pm = dynamic_cast< programmer* >( pe ) ) {       // èñïîëüçîâàòü pm äëÿ âûçîâà programmer::bonus()    }    else {       // èñïîëüçîâàòü ôóíêöèè-÷ëåíû êëàññà employee    }

}

Результат операции dynamic_cast

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

указывает на объект programmer. В противном случае результатом объявления будет 0 и выполняется ветвь else. Поскольку теперь оператор и проверка его результата находятся в одной инструкции программы, то невозможно случайно вставить какой-либо код между выполнением dynamic_cast и проверкой, так что pm



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

В предыдущем примере операция dynamic_cast

преобразует указатель на базовый класс в указатель на производный. Ее также можно применять для трансформации l-значения типа базового класса в ссылку на тип производного. Синтаксис такого использования dynamic_cast

следующий:

dynamic_cast< Type & >( lval )

где Type& – это целевой тип преобразования, а lval – l-значение типа базового класса. Операнд lval

успешно приводится к типу Type& только в том случае, когда lval

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

Поскольку нулевых ссылок не бывает (см. раздел 3.6), то проверить успешность выполнения операции путем сравнения результата (т.е. возвращенной оператором dynamic_cast

ссылки) с нулем невозможно. Если вместо указателей используются ссылки, условие

if ( programmer *pm = dynamic_cast< programmer* >( pe ) )

нельзя переписать в виде

if ( programmer &pm = dynamic_cast< programmer& >( pe ) )

Для извещения об ошибке в случае приведения к ссылочному типу оператор dynamic_cast

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

#include <typeinfo> void company::payroll( employee &re ) {    try {       programmer &rm = dynamic_cast< programmer & >( re );       // èñïîëüçîâàòü rm äëÿ âûçîâà programmer::bonus()    }    catch ( std::bad_cast ) {       // èñïîëüçîâàòü ôóíêöèè-÷ëåíû êëàññà employee    }

}

В случае неудачного завершения ссылочного варианта dynamic_cast возбуждается исключение типа bad_cast. Класс bad_cast

определен в стандартной библиотеке; для ссылки на него необходимо включить в программу заголовочный файл <typeinfo>. (Исключения из стандартной библиотеки мы будем рассматривать в следующем разделе.)

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

Оператор размещения new А

Существует третья форма оператора new, которая создает объект без отведения для него памяти, то есть в памяти, которая уже была выделена. Эту форму называют оператором размещения new. Программист указывает адрес области памяти, в которой размещается объект:

new (place_address) type-specifier

place_address

должен быть указателем. Такая форма (она включается заголовочным файлом <new>) позволяет программисту предварительно выделить большую область памяти, которая впоследствии будет содержать различные объекты. Например:

#include <iostream> #include <new> const int chunk = 16; class Foo { public:     int val() { return _val; }     FooQ(){ _val = 0; } private:     int _val; }; // выделяем память, но не создаем объектов Foo char *buf = new char[ sizeof(Foo) * chunk ]; int main() {     // создаем объект Foo в buf     Foo *pb = new (buf) Foo;     // проверим, что объект помещен в buf     if ( pb.val() == 0 )         cout << "Оператор new сработал!" << endl;     // здесь нельзя использовать pb     delete[] buf;     return 0;

}

Результат работы программы:

Оператор new сработал!

Для оператора размещения new нет парного оператора delete: он не нужен, поскольку эта форма не выделяет память. В предыдущем примере необходимо освободить память, адресуемую указателем buf, а не pb. Это происходит в конце программы, когда буфер больше не нужен. Поскольку buf

ссылается на символьный массив, оператор delete имеет форму

delete[] buf;

При уничтожении buf

прекращают существование все объекты, созданные в нем. В нашем примере pb

больше не ссылается на существующий объект класса Foo.

Упражнение 8.5

Объясните, почему приведенные операторы new

ошибочны:

(a) const float *pf = new const float[100]; (b) double *pd = new doub1e[10] [getDim()]; (c) int (*pia2)[ 1024 ] = new int[ ][ 1024 ];

(d) const int *pci = new const int;

Упражнение 8.6

Как бы вы уничтожили pa?

typedef int arr[10];

<
int *pa = new arr;

Упражнение 8.7

Какие из следующих операторов delete

содержат потенциальные ошибки времени выполнения и почему:

int globalObj; char buf[1000]; void f() {     int *pi = &global0bj;     double *pd = 0;     float *pf = new float(O);     int *pa = new(buf)int[20];     delete pi;   // (a)     delete pd;   // (b)     delete pf;   // (c)     de1ete[] pa; // (d)

}

Упражнение 8.8

Какие из данных объявлений auto_ptr

неверны или грозят ошибками времени выполнения? Объясните каждый случай.

int ix = 1024; int *pi = & ix; int *pi2 = new int ( 2048 ); (a) auto_ptr<int> p0(ix); (b) auto_ptr<int> pl(pi); (c) auto_ptr<int> p2(pi2); (d) auto_ptr<int> p3(&ix); (e) auto_ptr<int> p4(new int(2048)); (f) auto_ptr<int> p5(p2.get()); (9) auto_ptr<int> p6(p2.release());

(h) auto_ptr<int> p7(p2);

Упражнение 8.9

Объясните разницу между следующими инструкциями:

int *pi0 = p2.get();

int *pi1 = p2.release() ;

Для каких случаев более приемлем тот или иной вызов?

Упражнение 8.10

Пусть мы имеем:

auto_ptr< string > ps( new string( "Daniel" ) );

В чем разница между этими двумя вызовами assign()?Какой их них предпочтительнее и почему?

ps.get()->assign( "Danny" );

ps->assign( "Danny" );

Оператор размещения new() и оператор delete()

Оператор-член new()

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

class Screen { public:    void *operator new( size_t );    void *operator new( size_t, Screen * );    // ...

};

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

void func( Screen *start ) {    Screen *ps = new (start) Screen;    // ...

}

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

Можно также перегружать и оператор-член delete(). Однако такой оператор никогда не вызывается из выражения delete. Перегруженный delete()

неявно вызывается компилятором, если конструктор, вызванный при выполнении оператора new

(это не опечатка, мы действительно имеем в виду new), возбуждает исключение. Рассмотрим использование delete()

более внимательно.

Последовательность действий при вычислении выражения

Screen *ps = new ( start ) Screen;

такова:

1.      Вызывается определенный в классе оператор new(size_t, Screen*).

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

Переменная ps

инициализируется адресом нового объекта Screen.

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

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

Оператор разрешения области видимости

Имя члена пользовательского пространства дополняется поставленным спереди именем этого пространства и оператором разрешения области видимости (::). Использование неквалифицированного члена, например matrix, является ошибкой. Компилятор не знает, к какому объявлению относится это имя:

// определение интерфейса библиотеки #include "primer.h" // ошибка: нет объявления для matrix

void func( matrix &m );

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

// определение интерфейса библиотеки #include "primer.h" class matrix { /* пользовательское определение */ }; // правильно: глобальный тип matrix найден

void func( matrix &m );

то определение класса matrix

компилятор находит в глобальной области видимости и программа компилируется без ошибок. Поскольку объявление matrix как члена пространства имен cplusplus_primer

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

Именно поэтому мы говорим, что пространства имен решают проблему засорения глобального пространства: имена их членов невидимы, если имя пространства не указано явно, с помощью оператора разрешения области видимости. Существуют и другие механизмы, позволяющие сделать объявление члена пространства имен видимым вне его. Это using-объявления и using-директивы. Мы рассмотрим их в следующем разделе.

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

::member_name

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

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

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

#include <iostream> const int max = 65000; const int lineLength = 12; void fibonacci( int max ) {     if ( max < 2 ) return;         cout << "0 1 ";     int v1 = 0, v2 = 1, cur;     for ( int ix = 3; ix <= max; ++ix ) {         cur = v1 + v2;         if ( cur > ::max ) break;         cout << cur << " ";         vl = v2;         v2 = cur;         if (ix % "lineLength == 0) cout << end"!;     }

}

Так выглядит функция main(), вызывающая fibonacci():

#include <iostream> void fibonacci( int ); int main() {     cout << "Числа Фибоначчи: 16\n";     fibonacci( 16 );     return 0;

}

Результат работы программы:

Числа Фибоначчи: 16

0 1 1 2 3 5 8 13 21 34 55 89

144 233 377 610

Оператор sizeof

Оператор sizeof

возвращает размер в байтах объекта или типа данных. Синтаксис его таков:

sizeof ( type name ); sizeof ( object );

sizeof object;

Результат имеет специальный тип size_t, который определен как typedef в заголовочном файле cstddef. Вот пример использования обеих форм оператора sizeof:

#include <cstddef> int ia[] = { 0, 1, 2 }; // sizeof возвращает размер всего массива size_t array_size = sizeof ia; // sizeof возвращает размер типа int

size_t element_size = array_size / sizeof( int );

Применение sizeof к массиву дает количество байтов, занимаемых массивом, а не количество его элементов и не размер в байтах каждого из них. Так, например, в системах, где int

хранится в 4 байтах, значением array_size будет 12. Применение sizeof к указателю дает размер самого указателя, а не объекта, на который он указывает:

int *pi = new int[ 3 ];

size_t pointer_size = sizeof ( pi );

Здесь значением pointer_size

будет память под указатель в байтах (4 в 32-битных системах), а не массива ia.

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

#include <string> #include <iostream> #include <cstddef> int main() {     size_t ia;     ia = sizeof( ia ); //       правильно     ia = sizeof ia;    //       правильно     // ia = sizeof int; // ошибка     ia = sizeof( int ); // правильно     int *pi = new int[ 12 ];     cout << "pi: " << sizeof( pi )          << " *pi: " << sizeof( pi )          << endl;     // sizeof строки не зависит от     // ее реальной длины     string stl( "foobar" );     string st2( "a mighty oak" );     string *ps = &stl;     cout << " st1: " << sizeof( st1 )          << " st2: " << sizeof( st2 )          << " ps: sizeof( ps )          << " *ps: " << sizeof( *ps )          << endl;     cout << "short :\t"    << sizeof(short)    << endl;     cout << "shorf" :\t"   << sizeof(short*)   << endl;     cout << "short& :\t"   << sizeof(short&)   << endl;     cout << "short[3] :\t" << sizeof(short[3]) << endl;

<
}

Результатом работы программы будет:

pi: 4 *pi: 4

st1: 12 st2: 12 ps: 4 *ps:12

short : 2

short* : 4

short& : 2

short[3] : 6

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

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

Гарантируется, что в любой реализации С++ размер типа char равен 1.

// char_size == 1

size_t char_size = sizeof( char );

Значение оператора sizeof

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

// правильно: константное выражение

int array[ sizeof( some_type_T )];

Оператор “стрелка”

Оператор “стрелка”, разрешающий доступ к членам, может перегружаться для объектов класса. Он должен быть определен как функция-член и обеспечивать семантику указателя. Чаще всего этот оператор используется в классах, которые предоставляют “интеллектуальный указатель” (smart pointer), ведущий себя аналогично встроенным, но поддерживают и некоторую дополнительную функциональность.

Допустим, мы хотим определить тип класса для представления указателя на объект Screen (см. главу 13):

class ScreenPtr {    // ... private:    Screen *ptr;

};

Определение ScreenPtr

должно быть таким, чтобы объект этого класса гарантировано указывал на объект Screen: в отличие от встроенного указателя, он не может быть нулевым. Тогда приложение сможет пользоваться объектами типа ScreenPtr, не проверяя, указывают ли они на какой-нибудь объект Screen. Для этого нужно определить класс ScreenPtr с конструктором, но без конструктора по умолчанию (детально конструкторы рассматривались в разделе 14.2):

class ScreenPtr { public:    ScreenPtr( const Screen &s ) : ptr( &s ) { }    // ...

};

В любом определении объекта класса ScreenPtr

должен присутствовать инициализатор– объект класса Screen, на который будет ссылаться объект ScreenPtr:

ScreenPtr p1;   // ошибка: у класса ScreenPtr нет конструктора по умолчанию Screen myScreen( 4, 4 );

ScreenPtr ps( myScreen );  // правильно

Чтобы класс ScreenPtr вел себя как встроенный указатель, необходимо определить некоторые перегруженные операторы – разыменования (*) и “стрелку” для доступа к членам:

// перегруженные операторы для поддержки поведения указателя class ScreenPtr { public:    Screen& operator*()  { return *ptr; }    Screen* operator->() { return ptr; }    // ...

};

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

point->action();

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

Перегруженный оператор “стрелка” должен возвращать либо указатель на тип класса, либо объект класса, в котором он определен. Если возвращается указатель, то к нему применяется семантика встроенного оператора “стрелка”. В противном случае процесс продолжается рекурсивно, пока не будет получен указатель или определена ошибка. Например, так можно воспользоваться объектом ps

класса ScreenPtr для доступа к членам Screen:

ps->move( 2, 3 );

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

Ниже приводится небольшая программа для тестирования класса ScreenPtr. Объект типа ScreenPtr

используется точно так же, как любой объект типа Screen*:

#include <iostream> #include <string> #include "Screen.h" void printScreen( const ScreenPtr &ps ) {    cout << "Screen Object ( "         << ps->height() << ", "         << ps->width() << " )\n\n";    for ( int ix = 1; ix <= ps->height(); ++ix )    {       for ( int iy = 1; iy <= ps->width(); ++iy )          cout << ps->get( ix, iy );       cout << "\n";     } } int main() {    Screen sobj( 2, 5 );    string init( "HelloWorld" );    ScreenPtr ps( sobj );    // Установить содержимое экрана    string::size_type initpos = 0;    for ( int ix = 1; ix <= ps->height(); ++ix )       for ( int iy = 1; iy <= ps->width(); ++iy )       {          ps->move( ix, iy );          ps->set( init[ initpos++ ] );       }     // Вывести содержимое экрана     printScreen( ps );     return 0;

}

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

Оператор typeid

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

сообщает тип производного класса объекта:

#include <typeinfo> programmer pobj; employee &re = pobj; // ñ ôóíêöèåé name() ìû ïîçíàêîìèìñÿ â ïîäðàçäåëå, ïîñâÿùåííîì type_info // îíà âîçâðàùàåò C-ñòðîêó "programmer"

coiut << typeid( re ).name() << endl;

Операнд re

оператора typeid

имеет тип employee. Но так как re – это ссылка на тип класса с виртуальными функциями, то typeid

говорит, что тип адресуемого объекта – programmer (а не employee, на который ссылается re). Программа, использующая такой оператор, должна включать заголовочный файл <typeinfo>, что мы и сделали в этом примере.

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

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

int iobj; cout << typeid( iobj ).name() << endl;   // ïå÷àòàåòñÿ: int

cout << typeid( 8.16 ).name() << endl;   // печатается: double

Если операнд имеет тип класса, в котором нет виртуальных функций, то typeid

возвращает тип операнда, а не связанного с ним объекта:

class Base {  /* нет виртуальных функций */ }; class Derived : public Base { /* íåò âèðòóàëüíûõ ôóíêöèé */ }; Derived dobj; Base *pb = &dobj;

cout << typeid( *pb ).name() << endl;  // печатается: Base

Операнд typeid

имеет тип Base, т.е. тип выражения *pb. Поскольку в классе Base нет виртуальных функций, результатом typeid будет Base, хотя объект, на который указывает pb, имеет тип Derived.

Результаты, возвращенные оператором typeid, можно сравнивать. Например:

#include <typeinfo> employee *pe = new manager; employee& re = *pe; if ( typeid( pe ) == typeid( employee* ) )  // èñòèííî    // ÷òî-òî ñäåëàòü /* if ( typeid( pe ) == typeid( manager* ) )   // ëîæíî if ( typeid( pe ) == typeid( employee ) )   // ëîæíî if ( typeid( pe ) == typeid( manager )  )   // ëîæíî

*/

Условие в инструкции if

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

typeid( pe ) == typeid( employee* )

возвращает истину. Это удивит пользователей, привыкших писать:

// вызов виртуальной функции

pe->salary();

что приводит к вызову виртуальной функции salary() из производного класса manager. Поведение typeid(pe) не подчиняется данному механизму. Это связано с тем, что pe – указатель, а для получения типа производного класса операндом typeid



должен быть тип класса с виртуальными функциями. Выражение typeid(pe)

возвращает тип pe, т.е. указатель на employee. Это значение совпадает со значением typeid(employee*), тогда как все остальные сравнения дают ложь.

Только при употреблении выражения *pe в качестве операнда typeid

результат будет содержать тип объекта, на который указывает pe:

typeid( *pe ) == typeid( manager )    // истинно

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

В этих сравнениях *pe – выражение типа класса, который имеет виртуальные функции, поэтому результатом применения typeid

будет тип адресуемого операндом объекта manager.

Такой оператор можно использовать и со ссылками:

typeid( re ) == typeid( manager )     // истинно typeid( re ) == typeid( employee )    // ложно typeid( &re ) == typeid( employee* )  // истинно

typeid( &re ) == typeid( manager* )   // ложно

В первых двух сравнениях операнд re

имеет тип класса с виртуальными функциями, поэтому результат применения typeid

содержит тип объекта, на который ссылается re. В последних двух сравнениях операнд &re

имеет тип указателя, следовательно, результатом будет тип самого операнда, т.е. employee*.

На самом деле оператор typeid

возвращает объект класса типа type_info, который определен в заголовочном файле <typeinfo>. Интерфейс этого класса показывает, что можно делать с результатом, возвращенным typeid. (В следующем подразделе мы подробно рассмотрим этот интерфейс.)

Оператор вывода <<

Оператор вывода обычно применяется для записи на стандартный вывод cout. Например, программа

#include <iostream> int main() {     cout << "сплетница Анна Ливия\n";

}

печатает на терминале строку:

сплетница Анна Ливия

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

#include <iostream> #include <string.h> int main() {     cout << "Длина 'Улисс' равна:\t";     cout << strlen( "Улисс" );     cout << '\n';     cout << "Размер 'Улисс' равен:\t";     cout << sizeof( "Улисс" );     cout << endl;

}

выводит на терминал следующее:

Длина 'Улисс' равна:7

Размер 'Улисс' равен:8

endl – это манипулятор вывода, который вставляет в выходной поток символ перехода на новую строку, а затем сбрасывает буфер объекта ostream. (С буферизацией мы познакомимся в разделе 20.9.)

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

#include <iostream> #include <string.h> int main() {     // операторы вывода можно сцеплять     cout << "Длина 'Улисс' равна:\t";          << strlen( "Улисс" ) << '\n';     cout << "Размер 'Улисс' равен:\t"          << sizeof( "Улисс" ) << endl;

}

Сцепление операторов вывода (и ввода тоже) возможно потому, что результатом выражения

cout << "некоторая строка";

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

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

#include <iostream> int main() {     int i = 1024;     int *pi = &i;     cout << "i:   " << i          << "\t&i:\t" << &i << '\n';     cout << "*pi: "      << *pi          << "\tpi:\t"    << pi  << endl          << "\t\t&pi:\t" << &pi << endl;

}

выводит на терминал следующее:

i:   1024  &i: 0x7fff0b4

*pi: 1024  pi: 0x7fff0b4

          &pi: 0x7fff0b0

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

Следующая программа ведет себя странно. Мы хотим напечатать адрес, хранящийся в переменной pstr:

#include <iostream> const char *str = "vermeer"; int main() {    const char *pstr = str;    cout << "Адрес pstr равен: "         << pstr << endl;

}

Но после компиляции и запуска программа неожиданно выдает такую строку:

Адрес pstr равен: vermeer

Проблема в том, что тип const char*

интерпретируется как C-строка. Чтобы все же напечатать адрес, хранящийся в pstr, необходимо подавить обработку типа const char* по умолчанию. Для этого мы сначала убираем спецификатор const, а затем приводим pstr к типу void*:

<< static_cast<void*>(const_cast<char*>(pstr))

Теперь программа

выводит ожидаемый результат:

Адрес pstr равен: 0x116e8

А вот еще одна загадка. Нужно напечатать большее из двух чисел:

#include <iostream> inline void max_out( int val1, int val2 ) {    cout << ( val1 > val2 ) ? val1 : val2; } int main() {     int ix = 10, jx = 20;     cout << "Большее из " << ix          << ", " << jx << " равно ";     max_out( ix, jx );     cout << endl;

<


}

Однако программа выдает неправильный результат:

Большее из 10, 20 равно 0

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

cout << ( val1 > val2 ) ? val1 : val2;

вычисляется как

(cout << ( val1 > val2 )) ? val1 : val2;

Поскольку val1 не больше val2, то результатом сравнения будет false, обозначаемый нулем. Чтобы изменить приоритет операций, весь оператор условного выражения следует заключить в скобки:

cout << ( val1 > val2  ? val1 : val2 );

Теперь результат получается правильный:

Большее из 10, 20 равно 20

Такого рода ошибку было бы проще найти, если бы значения литералов true и false

типа bool

печатались как строки, а не как 1 и 0. Тогда мы увидели бы строку:

Большее из 10, 20 равно false

и все стало бы ясно. По умолчанию литерал false

печатается как 0, а true – как 1. Это можно изменить, воспользовавшись манипулятором boolalpha(), что и сделано в следующей программе:

int main() {                                       cout << "печать значений типа bool по умолчанию: "                 << true << " " << false                 << "\nи в виде строк: "                 << boolalpha()                 << true << " " << false                 << endl;

}

Вот результат:

печать значений типа bool по умолчанию: 1 0

и в виде строк: true false

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

#include <iostream> #include <vector> #include <string> string pooh_pals[] = {            "Тигра", "Пятачок", "Иа-Иа", "Кролик" }; int main() {            vector<string> ppals( pooh_pals, pooh_pals+4 );      vector<string>::iterator iter = ppals.begin();      vector<string>::iterator iter_end = ppals.end();            cout << "Это друзья Пуха: ";            for ( ; iter != iter_end; iter++ )                  cout << *iter << " ";            cout << endl;

<


}

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

#include <iostream> #include <algorithm> #include <vector> #include <string> string pooh_pals[] = {            "Тигра", "Пятачок", "Иа-Иа", "Кролик" }; int main() {            vector<string> ppals( pooh_pals, pooh_pals+4 );      vector<string>::iterator iter = ppals.begin();      vector<string>::iterator iter_end = ppals.end();            cout << "Это друзья Пуха: ";      // копируем каждый элемент в cout ...            ostream_iterator< string > output( cout, " " );            copy( iter, iter_end, output );            cout << endl;

}

Программа печатает такую строку:

Ýòî äðóçüÿ Ïóõà: Òèãðà Ïÿòà÷îê Èà-Èà Êðîëèê

Упражнение 20.1

Даны следующие определения объектов:

string sa[4] = { "пух", "тигра", "пятачок", "иа-иа" }; vector< string > svec( sa, sa+4 ); string robin( "кристофер робин" ); const char *pc = robin.c_str(); int ival = 1024; char blank = ' '; double dval = 3.14159;

complex purei( 0, 7 );

(a)    Направьте значение каждого объекта в стандартный вывод.

(b)   Напечатайте значение адреса pc.

(c)    Напечатайте наименьшее из двух значений ival и dval, пользуясь оператором условного выражения:

ival < dval ? ival : dval

Оператор вызова функции

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

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

class absInt { public:    int operator()( int val ) {       int result = val < 0 ? -val : val;       return result;    }

};

Перегруженный оператор operator()

должен быть объявлен как функция-член с произвольным числом параметров. Параметры и возвращаемое значение могут иметь любые типы, допустимые для функций (см. разделы 7.2, 7.3 и 7.4). operator() вызывается путем применения списка аргументов к объекту того класса, в котором он определен. Мы рассмотрим, как он используется в одном из обобщенных алгоритмов, описанных в главе 12. В следующем примере обобщенный алгоритм transform() вызывается для применения определенной в absInt

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

#include <vector> #include <algoritm> int main() {    int ia[] = { -0, 1, -1, -2, 3, 5, -5, 8 };    vector< int > ivec( ia, ia+8 );    // заменить каждый элемент его абсолютным значением    transform( ivec.begin(), ivec.end(), ivec.begin(), absInt() );    // ...

}

Первый и второй аргументы transform()

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

Четвертый аргумент – это временный объект класса absInt, создаваемый с помощью конструктора по умолчанию. Конкретизация обобщенного алгоритма transform(), вызываемого из main(), могла бы выглядеть так:

typedef vector< int >::iterator iter_type; // конкретизация transform() // операция absInt применяется к элементу вектора int iter_type transform( iter_type iter, iter_type last,                      iter_type result, absInt func ) {    while ( iter != last )       *result++ = func( *iter++ );  // вызывается absInt::operator()    return iter;

}

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

класса absInt. Этому оператору передается аргумент *iter, указывающий на тот элемент вектора, для которого мы хотим получить абсолютное значение.

Оператор взятия индекса

Оператор взятия индекса operator[]()

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

У пользователей String

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

String entry( "extravagant" ); String mycopy; for ( int ix = 0; ix < entry.size(); ++ix )

   mycopy[ ix ] = entry[ ix ];

Оператор взятия индекса может появляться как слева, так и справа от оператора присваивания. Чтобы быть в левой части, он должен возвращать l-значение индексируемого элемента. Для этого мы возвращаем ссылку:

#include <cassert> inine char& String::operator[]( int elem ) const {    assert( elem >= 0 && elem < _size );    return _string[ elem ];

}

В следующем фрагменте нулевому элементу массива color присваивается символ 'V':

String color( "violet" );

color[ 0 ] = 'V';

Обратите внимание, что в определении оператора проверяется выход индекса за границы массива. Для этого используется библиотечная C-функция assert(). Можно также возбудить исключение, показывающее, что значение elem меньше 0 или больше длины C-строки, на которую ссылается _string. (Возбуждение и обработка исключений обсуждались в главе 11.)

Оператор “запятая”

Одно выражение может состоять из набора подвыражений, разделенных запятыми;  такие подвыражения вычисляются слева направо. Конечным результатом будет результат самого правого из них. В следующем примере каждое из подвыражений условного оператора представляет собой список. Результатом первого подвыражения условного оператора является 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;

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 и Ma­trixLib.

Однако обратите внимание на тип 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 и в пространстве Ma­trixLib. В последнем случае это выглядит так:

// ---- 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, создает два объекта: вектор строк, хранящий все слова текста, и вектор позиций, хранящий пары (номер строки, номер колонки) для каждого слова. Таким образом, первый объект дает нам множество значений ключей нашего отображения, а второй – множество ассоциированных с ними значений.



}

Синтаксически сложное выражение

(*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 );     // ...

}



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]);

<

Определение объекта 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

могло бы выглядеть так:

должен поддерживать также коллекции объектов типа 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 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

Определения пространства имен

Определение пользовательского пространства имен начинается с ключевого слова 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 в одну программу.

Определения пространства имен А

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

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

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

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.)

Определения шаблонов классов 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. Другая категория специальных функций, которая рассматривается в этой главе, – это функции преобразования членов (конвертеры), составляющие набор стандартных преобразований для типа класса. Они неявно применяются компилятором, когда объекты классов используются в качестве фактических аргументов функции или операндов встроенных или перегруженных операторов. Завершается глава развернутым изложением правил разрешения перегрузки функций с учетом передачи объектов в качестве аргументов, функций-членов класса и перегруженных операторов.

Перегрузка и область видимости A

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

#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[]() возбуждал при ее выполнении исключение.

---

---