Читаем текстовый файл

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

Как получить одну строку текста? Стандартная библиотека предоставляет для этого функцию getline():

istream&

getline( istream &is, string str, char delimiter );

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

Мы будем помещать каждую такую строку в вектор.

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

Вот реализация функции ввода файла:[15]

// возвращаемое значение - указатель на строковый вектор

vector<string,allocator>*

retrieve_text()

{

    string file_name;

    cout << "please enter file name: ";

    cin >> file_name;

    // откроем файл для ввода ...

    ifstream 1nfile( file_name.c_str(), ios::in );

    if ( ! infile ) {

        cerr << "oops! unable to open file "

             << file_name << " -- bailing out!\n";

        exit( -1 );

    }

    else cout << '\n';

    vector<string, allocator> *1ines_of_text =

        new vector<string, allocator>;

    string textime;

    typedef pair<string::size_type, int> stats;

    stats maxline;

    int   linenum = 0;

    while ( getline( infile, textline, '\n' )) {

        cout << "line read: " << textline << '\n';

        if ( maxline.first < textline.size() ) {

            maxline.first = textline.size() ;

            maxline.second = linenum;

        }

        1ines_of_text->push_back( textline );

        linenum++;

    }

    return lines_of_text;

}

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

please enter file name: a1ice_emma

line read: Alice Emma has long flowing red hair. Her Daddy says

line read: when the wind blows through her hair, it looks

           almost alive,

line read: like a fiery bird in flight. A beautiful fiery bird,

           he tells her,

line read: magical but untamed. "Daddy, shush, there is no such

           thing, "

line read: she tells him, at the same time wanting him to tell

           her more.

line read: Shyly, she asks, "I mean. Daddy, is there?"

number of lines: 6

maximum length: 66

longest line: like a fiery bird in flight. A beautiful fiery

              bird, he tells her,

После того как все строки текста сохранены, нужно разбить их на слова. Сначала мы отбросим знаки препинания. Например, возьмем строку из части “Anna Livia Plurrabelle” романа “Finnegans Wake”.

"For every tale there's a telling,

and that's the he and she of it."

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

"For

there's

telling,

that's

it."

А хотелось бы получить:

For

there

telling

that

it

Можно возразить, что

there's

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

there is

но мы-то движемся в другом направлении: следующий шаг – это отбрасывание семантически нейтральных слов, таких, как is, that, and, it и т.д. Так что для данной строчки из “Finnegans Wake” только два слова являются значимыми: tale и telling, и только по этим словам будет выполняться поиск. (Мы реализуем набор стоп-слов с помощью контейнерного типа set, который подробно рассматривается в следующем разделе.)

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

Home is where the heart is.

A home is where they have to let you in.

Несомненно, запрос слова home должен найти обе строки.

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

и dogs, love, loving

и loved

рассматривались системой как одинаковые.

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

Члены и не члены класса

Рассмотрим операторы равенства в нашем классе String более внимательно. Первый оператор позволяет устанавливать равенство двух объектов, а второй – объекта и C-строки:

#include "String.h"

int main() {

   String flower;

   // что-нибудь записать в переменную flower

   if ( flower == "lily" )  // правильно

      // ...

   else

   if ( "tulip" == flower )  // ошибка

      // ...

}

При первом использовании оператора равенства в main() вызывается перегруженный operator==(const char *) класса String. Однако на второй инструкции if компилятор выдает сообщение об ошибке. В чем дело?

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

операндом служит объект этого класса. Поскольку во втором случае левый операнд не принадлежит к классу String, компилятор пытается найти такой встроенный оператор, для которого левым операндом может быть C-строка, а правым – объект класса String. Разумеется, его не существует, поэтому компилятор говорит об ошибке.

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

if ( String( "tulip" ) == flower )  //правильно: вызывается оператор-член

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

class Text {

public:

   Text( const char * = 0 );

   Text( const Text & );

   // набор перегруженных операторов равенства

   bool operator==( const char * ) const;

   bool operator==( const String & ) const;

   bool operator==( const Text & ) const;

   // ...

};

и выражение в main() можно переписать так:

if ( Text( "tulip" ) == flower )  // вызывается Text::operator==()

Следовательно, чтобы найти подходящий для сравнения оператор равенства, компилятору придется просмотреть все определения классов в поисках конструктора, способного привести левый операнд к некоторому типу класса. Затем для каждого из таких типов нужно проверить все ассоциированные с ним перегруженные операторы равенства, чтобы понять, может ли хоть один из них выполнить сравнение. А после этого компилятор должен решить, какая из найденных комбинаций конструктора и оператора равенства (если таковые нашлись) лучше всего соответствует операнду в правой части! Если потребовать от компилятора выполнения всех этих действий, то время трансляции программ C++ резко возрастет. Вместо этого компилятор просматривает только перегруженные операторы, определенные как члены класса левого операнда (и его базовых классов, как мы покажем в главе 19).

Разрешается, однако, определять перегруженные операторы, не являющиеся членами класса. При анализе строки в main(), вызвавшей ошибку компиляции, подобные операторы принимались во внимание. Таким образом, сравнение, в котором C-строка стоит в левой части, можно сделать корректным, если заменить операторы равенства, являющиеся членами класса String, на операторы равенства, объявленные в области видимости пространства имен:

bool operator==( const String &, const String & );

bool operator==( const String &, const char * );

Обратите внимание, что эти глобальные перегруженные операторы имеют на один параметр больше, чем операторы-члены. Если оператор является членом класса, то первым параметром неявно передается указатель this. То есть для операторов-членов выражение

flower == "lily"

переписывается компилятором в виде:

flower.operator==( "lily" )

и на левый операнд flower в определении перегруженного оператора-члена можно сослаться с помощью this. (Указатель this введен в разделе 13.4.) В случае глобального перегруженного оператора параметр, представляющий левый операнд, должен быть задан явно.

Тогда выражение

flower == "lily"

вызывает оператор

bool operator==( const String &, const char * );

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

"tulip" == flower

Мы ведь не определили такой перегруженный оператор:

bool operator==( const char *, const String & );

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

operator==( String("tulip"), flower );

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

bool operator==( const String &, const String & );

Но тогда зачем мы предоставили второй перегруженный оператор:



bool operator==( const String &, const char * );

Преобразование типа из C-строки в класс String может быть применено и к правому операнду. Функция main() будет компилироваться без ошибок, если просто определить в пространстве имен перегруженный оператор, принимающий два операнда String:

bool operator==( const String &, const String & );

Предоставлять ли только этот оператор или еще два:

bool operator==( const char *, const String & );

bool operator==( const String &, const char * );

зависит от того, насколько велики затраты на преобразование из C-строки в String во время выполнения, то есть от “стоимости” дополнительных вызовов конструктора в программах, пользующихся нашим классом String. Если оператор равенства будет часто использоваться для сравнения C-строк и объектов , то лучше предоставить все три варианта. (Мы вернемся к вопросу эффективности в разделе, посвященном друзьям.

Подробнее о приведении к типу класса с помощью конструкторов мы расскажем в разделе 15.9; в разделе 15.10 речь пойдет о разрешении перегрузки функций с помощью описанных преобразований, а в разделе 15.12 – о разрешении перегрузки операторов.)

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

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

язык требует, чтобы операторы присваивания ("="), взятия индекса ("[]"), вызова ("()") и доступа к членам по стрелке ("->") были определены как члены класса. В противном случае выдается сообщение об ошибке компиляции:

// ошибка: должен быть членом класса

char& operator[]( String &, int ix );

(Подробнее оператор присваивания рассматривается в разделе 15.3, взятия индекса – в разделе 15.4, вызова – в разделе 15.5, а оператор доступа к члену по стрелке – в разделе 15.6.)

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

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

bool operator==( const String &str1, const String &str2 )

{

   if ( str1.size() != str2.size() )

      return false;

   return strcmp( str1.c_str(), str2.c_str() ) ? false : true ;

}

inline bool operator==( const String &str, const char *s )

{

   return strcmp( str.c_str(), s ) ? false : true ;

}

Что такое переменная

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

int    student_count;

double salary;

bool   on_loan;

strins street_address;

char   delimiter;

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

собственно значение, или r-значение (от read value – значение для чтения), которое хранится в этой области памяти и присуще как переменной, так и литералу;

значение адреса области памяти, ассоциированной с переменной, или l-значение (от location value – значение местоположения) – место, где хранится r-значение; присуще только объекту.

В выражении

ch = ch - '0';

переменная ch находится и слева и справа от символа операции присваивания. Справа расположено значение для чтения (ch и символьный литерал '0'): ассоциированные с переменной данные считываются из соответствующей области памяти. Слева – значение местоположения: в область памяти, соотнесенную с переменной ch, помещается результат вычитания. В общем случае левый операнд операции присваивания должен быть l-значением. Мы не можем написать следующие выражения:

// ошибки компиляции: значения слева не являются l-значениями

// ошибка: литерал - не l-значение

0 = 1;

// ошибка: арифметическое выражение - не l-значение

salary + salary * 0.10 = new_salary;

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

// файл module0.C

// определяет объект fileName

string fileName;

// ... присвоить fileName значение

// файл module1.C

// использует объект fileName

// увы, не компилируется:

// fileName не определен в module1.C

ifstream input_file( fileName );

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

// файл module1.C

// использует объект fileName

// fileName объявляется, то есть программа получает

// информацию об этом объекте без вторичного его определения

extern string fileName;

ifstream input_file( fileName )

Объявление переменной сообщает компилятору, что объект с данным именем, имеющий данный тип, определен где-то в программе. Память под переменную при ее объявлении не отводится. (Ключевое слово extern рассматривается в разделе 8.2.)

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

Что такое выражение?

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

void mumble() {

    3.14159;

    "melancholia";

    upperBound;

}

Результатом вычисления выражения 3.14159 станет 3.14159 типа double, выражения "melancholia" – адрес первого элемента строки типа const char*. Значение выражения upperBound – это значение объекта upperBound, а его типом будет тип самого объекта.

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

salary + raise

ivec[ size/2 ] * delta

first_name + " " + 1ast_name

Операции обозначаются соответствующими знаками. В первом примере сложение применяется к salary и raise. Во втором выражении size делится на 2. Частное используется как индекс для массива ivec. Получившийся в результате операции взятия индекса элемент массива умножается на delta. В третьем примере два строковых объекта конкатенируются между собой и со строковым литералом, создавая новый строковый объект.

Операции, применяемые к одному операнду, называются унарными (например, взятие адреса (&) и разыменование (*)), а применяемые к двум операндам – бинарными. Один и тот же символ может обозначать разные операции в зависимости от того, унарна она или бинарна. Так, в выражении

*ptr

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

var1 * var2

то звездочка будет обозначать бинарную операцию умножения.

Результатом вычисления выражения всегда, если не оговорено противное, является r-значение. Тип результата арифметического выражения определяется типами операндов. Если операнды имеют разные типы, производится преобразование типов в соответствии с предопределенным набором правил. (Мы детально рассмотрим эти правила в разделе 4.14.)

Выражение может являться составным, то есть объединять в себе несколько подвыражений. Вот, например, выражение, проверяющее на неравенство нулю указатель и объект, на который он указывает (если он на что-то указывает)[7]:

ptr != 0 && *ptr != 0

Выражение состоит из трех подвыражений: проверку указателя ptr, разыменования ptr и проверку результата разыменования. Если ptr определен как

int ival = 1024;

int *ptr = &ival;

то результатом разыменования будет 1024 и оба сравнения дадут истину. Результатом всего выражения также будет истина (оператор && обозначает логическое И).

Если посмотреть на этот пример внимательно, можно заметить, что порядок выполнения операций очень важен. Скажем, если бы операция разыменования ptr производилась до его сравнения с 0, в случае нулевого значения ptr это скорее всего вызвало бы крах программы. В случае операции И порядок действий строго определен: сначала оценивается левый операнд, и если его значение равно false, правый операнд не вычисляется вовсе. Порядок выполнения операций определяется их приоритетами, не всегда очевидными, что вызывает у начинающих программистов на С и С++ множество ошибок. Приоритеты будут приведены в разделе 4.13, а пока мы расскажем обо всех операциях, определенных в С++, начиная с наиболее привычных.

Данные-члены

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

#include <string>

class Screen {

   string             _screen;   // string( _height * _width )

   string::size_type  _cursor;   // текущее положение на экране

   short              _height;   // число строк

   short              _width;    // число колонок

};

Поскольку мы решили использовать строки для внутреннего представления объекта класса Screen, то член _screen имеет тип string. Член _cursor– это смещение в строке, он применяется для указания текущей позиции на экране. Для него использован переносимый тип string::size_type. (Тип size_type рассматривался в разделе 6.8.)

Необязательно объявлять два члена типа short по отдельности. Вот объявление класса Screen, эквивалентное приведенному выше:

class Screen {

/*

 * _ screen адресует строку размером _height * _width

 * _cursor указывает текущую позицию на экране

 * _height и _width - соответственно число строк и колонок

 */

   string             _screen;

   string::size_type  _cursor;

   short              _height, _width;

};

Член класса может иметь любой тип:

class StackScreen {

   int topStack;

   void (*handler)();     // указатель на функцию

   vector<Screen> stack;  // вектор классов

};

Описанные данные-члены называются нестатическими. Класс может иметь также и статические

данные-члены. (У них есть особые свойства, которые мы рассмотрим в разделе 13.5.)

Объявления данных-членов очень похожи на объявления переменных в области видимости блока или пространства имен. Однако их, за исключением статических членов, нельзя явно инициализировать в теле класса:

class First {

   int    memi = 0;    // ошибка

   double memd = 0.0;  // ошибка

};

Данные-члены класса инициализируются с помощью конструктора класса. (Мы рассказывали о конструкторах в разделе 2.3; более подробно они рассматриваются в главе 14.)

Деструктор класса

Одна из целей, стоящих перед конструктором,– обеспечить автоматическое выделение ресурса. Мы уже видели в примере с классом Account конструктор, где с помощью оператора new выделяется память для массива символов и присваивается уникальный номер счету. Можно также представить ситуацию, когда нужно получить монопольный доступ к разделяемой памяти или к критической секции потока. Для этого необходима симметричная операция, обеспечивающая автоматическое освобождение памяти или возврат ресурса по завершении времени жизни объекта, – деструктор. Деструктор – это специальная определяемая пользователем функция-член, которая автоматически вызывается, когда объект выходит из области видимости или когда к указателю на объект применяется операция delete. Имя этой функции образовано из имени класса с предшествующим символом “тильда” (~). Деструктор не возвращает значения и не принимает никаких параметров, а следовательно, не может быть перегружен. Хотя разрешается определять несколько таких функций-членов, лишь одна из них будет применяться ко всем объектам класса. Вот, например, деструктор для нашего класса Account:

class Account {

public:

           Account();

     explicit Account( const char*, double=0.0 );

           Account( const Account& );

     ~Account();

     // ...

private:

           char         *_name;

           unsigned int _acct_nmbr;

           double       _balance;

};

inline

Account::~Account()

{

      delete [] _name;

      return_acct_number( _acct_nnmbr );

}

Обратите внимание, что в нашем деструкторе не сбрасываются значения членов:

inline

Account::~Account()

{

      // необходимо

      delete [] _name;

      return_acct_number( _acct_nnmbr );

      // необязательно

      _name = 0;

      _balance = 0.0;

      _acct_nmbr = 0;

}

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

class Point3d {

public:

   // ...

private:

   float x, y, z;

};

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

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

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

{

   // начало критического участка программы

#ifdef PROFILE

   Timer t;

#endif

   // критический участок

   // t уничтожается автоматически

   // отображается затраченное время ...

}

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

(1)    #include "Account.h"

(2)    Account global( "James Joyce" );

(3)    int main()

(4)    {

(5)       Account local( "Anna Livia Plurabelle", 10000 );

(6)       Account &loc_ref = global;

(7)       Account *pact = 0;

(8)

(9)       {

(10)          Account local_too( "Stephen Hero" );

(11)          pact = new Account( "Stephen Dedalus" );

(12)      }

(13)

(14)      delete pact;



(15)    }

Сколько здесь вызывается конструкторов? Четыре: один для глобального объекта global в строке (2); по одному для каждого из локальных объектов local и local_too в строках (5) и (10) соответственно, и один для объекта, распределенного в хипе, в строке (11). Ни объявление ссылки loc_ref на объект в строке (6), ни объявление указателя pact в строке (7) не приводят к вызову конструктора. Ссылка – это псевдоним для уже сконструированного объекта, в данном случае для global. Указатель также лишь адресует объект, созданный ранее (в данном случае распределенный в хипе, строка (11)), или не адресует никакого объекта (строка (7)).

Аналогично вызываются четыре деструктора: для глобального объекта global, объявленного в строке (2), для двух локальных объектов и для объекта в хипе при вызове delete в строке (14). Однако в программе нет инструкции, с которой можно связать вызов деструктора. Компилятор просто вставляет эти вызовы за последним использованием объекта, но перед закрытием соответствующей области видимости.

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

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

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

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

if (pact != 0 ) delete pact;

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

#include <memory>

#include "Account.h"

Account global( "James Joyce" );

int main()

{

   Account local( "Anna Livia Plurabelle", 10000 );

   Account &loc_ref = global;

   auto_ptr<Account> pact( new Account( "Stephen Dedalus" ));

   {

      Account local_too( "Stephen Hero" );

   }

   // объект auto_ptr уничтожается здесь

}

Деструкторы

Когда заканчивается время жизни объекта производного класса, автоматически вызываются деструкторы производного и базового классов (если они определены), а также деструкторы всех объектов-членов. Например, если имеется объект класса NameQuery:

NameQuery nq( "hyperion" );

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

Вот деструкторы нашего базового Query и производных от него (все они объявлены открытыми членами соответствующих классов):

inline Query::

~Query(){ delete _solution; }

inline NotQuery::

~NotQuery(){ delete _op; }

inline OrQuery::

~OrQuery(){ delete _lop; delete _rop; }

inline AndQuery::

~AndQuery(){ delete _lop; delete _rop; }

Отметим два аспекта:

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

в деструкторах производных классов оператор delete применяется к указателю типа Query*. Чтобы вызвать не деструктор Query, а деструктор класса того объекта, который фактически адресуется этим указателем, мы должны объявить деструктор базового Query виртуальным. (Более подробно о виртуальных функциях вообще и о виртуальных деструкторах в частности мы поговорим в следующем разделе.)

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

В разделе 17.7 мы инкапсулируем выделение памяти и конструирование объектов иерархии Query в управляющий класс UserQuery. Это гарантирует выполнение нашего предположения. На уровне программы в целом следует перегрузить операторы new и delete для классов иерархии. Например, можно поступить следующим образом. Оператор new устанавливает в объекте флажок, говорящий, что память для него выделена из хипа. Перегруженный оператор delete проверяет этот флажок: если он есть, то память освобождается с помощью стандартного оператора delete.

Упражнение 17.7

Идентифицируйте конструкторы и деструкторы базового и производных классов для той иерархии, которую вы выбрали в упражнении 17.2 (раздел 17.1).

Упражнение 17.8

Измените реализацию класса OrQuery так, чтобы он был производным от BinaryQuery.

Упражнение 17.9

Найдите ошибку в следующем определении класса:

class Object {

public:

   virtual ~Object();

   virtual string isA();

protected:

   string _isA;

private:

   Object( string s ) : _isA( s ) {}

};

Упражнение 17.10

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

class ConcreteBase {

public:

   explicit ConcreteBase( int );

   virtual ostream& print( ostream& );

   virtual ~Base();

   static int object_count();

protected:

   int _id;

   static int _object_count;

};

Что неправильно в следующих фрагментах:

(a) class C1 : public ConcreteBase {

    public:

       C1( int val )

         : _id( _object_count++ ) {}

       // ...

    };

(b) class C2 : public C1 {

    public:

       C2( int val )

         : ConcreteBase( val ), C1( val ) {}

       // ...

    };

(c) class C3 : public C2 {

    public:

       C3( int val )

         : C2( val ), _object_count( val ) {}

       // ...

    };

(d) class C4 : public ConcreteBase {

    public:

       C4( int val )

         : ConcreteBase ( _id+val ){}

       // ...

    };

Упражнение 17.11

В первоначальном определении языка C++ порядок следования инициализаторов в списке инициализации членов определял порядок вызова конструкторов. Принцип, который действует сейчас, был принят в 1986 году. Как вы думаете, почему была изменена исходная спецификация?

Детали разрешения перегрузки функций

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

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

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

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

Теперь мы готовы к тому, чтобы изучить эти шаги более детально.

Динамически размещаемые объекты

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

Третий вид объектов позволяет программисту полностью управлять выделением и освобождением памяти. Такие объекты называют динамически размещаемыми или, для краткости, просто динамическими. Динамический объект “живет” в пуле свободной памяти, называемой хипом. Программист создает его с помощью оператора new, а уничтожает с помощью оператора delete. Динамически размещаться может как единичный объект, так и массив объектов. Размер массива, размещаемого в хипе, разрешается задавать во время выполнения.

В этом разделе, посвященном динамическим объектам, мы рассмотрим три формы оператора new: для размещения единичного объекта, для размещения массива и третью форму, называемую оператором размещения new (placement new expression). Когда хип исчерпан, этот оператор возбуждает исключение. (Разговор об исключениях будет продолжен в главе 11. В главе 15 мы расскажем об операторах new и delete применительно к классам.)

Динамическое создание и уничтожение единичных объектов

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

new int;

размещает в хипе один объект типа int. Аналогично в результате выполнения инструкции

new iStack;

там появится один объект класса iStack.

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

int *pi = new int;

Здесь оператор new создает один объект типа int, на который ссылается указатель pi. Выделение памяти из хипа во время выполнения программы называется динамическим

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

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

if ( *pi == 0 )

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

int *pi = new int( 0 );

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

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

int ival = 0;    // создаем объект типа int и инициализируем его 0

int *pi = &ival; // указатель ссылается на этот объект

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

iStack *ps = new iStack( 512 );

создает объект типа iStack на 512 элементов. В случае объекта класса значение или значения в скобках передаются соответствующему конструктору, который вызывается в случае успешного выделения памяти. (Динамическое создание объектов классов более подробно рассматривается в разделе 15.8. Оставшаяся часть данного раздела посвящена созданию объектов встроенных типов.)

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

Время жизни объекта, на который указывает pi, заканчивается при освобождении памяти, где этот объект размещен. Это происходит, когда pi передается оператору delete. Например,

delete pi;

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

Глядя на предыдущий пример, вы можете спросить: а что случится, если значение pi по какой-либо причине было нулевым? Не следует ли переписать этот код таким образом:

// необходимо ли это?

if ( pi != 0 )

    delete pi;

Нет. Язык С++ гарантирует, что оператор delete не будет вызывать функцию delete() в случае нулевого операнда. Следовательно, проверка на 0 необязательна. (Если вы явно добавите такую проверку, в большинстве реализаций она фактически будет выполнена дважды.)

Важно понимать разницу между временем жизни указателя pi и объекта, который он адресует. Сам объект pi является глобальным и объявлен в глобальной области видимости. Следовательно, память под него выделяется до выполнения программы и сохраняется за ним до ее завершения. Совсем не так определяется время жизни адресуемого указателем pi объекта, который создается с помощью оператора new во время выполнения. Область памяти, на которую указывает pi, выделена динамически, следовательно, pi является указателем на динамически размещенный объект типа int. Когда в программе встретится оператор delete, эта память  будет освобождена. Однако память, отведенная самому указателю pi, не освобождается, а ее содержимое не изменяется. После выполнения delete объект pi становится висячим указателем, то есть ссылается на область памяти, не принадлежащую программе. Такой указатель служит источником трудно обнаруживаемых ошибок, поэтому сразу после уничтожения объекта ему полезно присвоить 0, обозначив таким образом, что указатель больше ни на что не ссылается.



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

Ниже приведены примеры опасных и безопасных операторов delete:

void f() {

    int i;

    string str = "dwarves";

    int *pi = &i;

    short *ps = 0;

    double *pd = new doub1e(33);

    delete str; // плохо: str не является динамическим объектом

    delete pi; // плохо: pi ссылается на локальный объект

    delete ps; // безопасно

    delete pd; // безопасно

}

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

не освободить выделенную память. В таком случае память не возвращается в хип. Эта ошибка получила название утечки памяти;

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

изменять объект после его удаления. Такое часто случается, поскольку указатель, к которому применяется оператор delete, не обнуляется.

Эти ошибки при работе с динамически выделяемой памятью гораздо легче допустить, нежели обнаружить и исправить. Для того чтобы помочь программисту, стандартная библиотека С++ представляет класс auto_ptr. Мы рассмотрим его в следующем подразделе. После этого мы покажем, как динамически размещать и уничтожать массивы, используя вторую форму операторов new и delete.

Динамическое создание и уничтожение константных объектов

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

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

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

Во-вторых, указатель, возвращаемый выражением  new, должен адресовать константу. В предыдущем примере pci служит указателем на const int.

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

delete pci;

Хотя операнд оператора delete имеет тип указателя на const int, эта инструкция является корректной и освобождает область памяти, на которую ссылается pci.

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

const int *pci = new const int[100]; // ошибка

Динамическое создание и уничтожение массивов

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

// создание единственного объекта типа int

// с начальным значением 1024

int *pi = new int( 1024 );

// создание массива из 1024 элементов

// элементы не инициализируются

int *pia = new int[ 1024 ];

// создание двумерного массива из 4x1024 элементов

int (*pia2)[ 1024 ] = new int[ 4 ][ 1024 ];

pi содержит адрес единственного элемента типа int, инициализированного значением 1024; pia– адрес первого элемента массива из 1024 элементов; pia2 – адрес начала массива, содержащего четыре массива по 1024 элемента, т.е. pia2 адресует 4096 элементов.

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

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

    pia[ index ] = 0;

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

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

Оператор new допустимо использовать для задания первого измерения массива с помощью значения, вычисляемого во время выполнения. Предположим, у нас есть следующие C-строки:

const char *noerr = "success";

// ...

const char *err189 = "Error: a function declaration must "

                     "specify a function return type!";

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

#include <cstring>

const char *errorTxt;

if (errorFound)

    errorTxt = errl89;

else

    errorTxt = noerr;

int dimension = strlen( errorTxt ) + 1;

char *strl = new char[ dimension ];

// копируем текст ошибки в strl

strcpy( strl, errorTxt );

dimension разрешается заменить выражением:

// обычная для С++ идиома,

// иногда удивляющая начинающих программистов

char *strl = new char[ str1en( errorTxt ) + 1 ];

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

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

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

int getDim();

// создание двумерного массива

int (*pia3)[ 1024 ] = new int[ getDim() ][ 1024 ]; // правильно

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

int **pia4 = new int[ 4 ][ getDim() ];

Оператор delete для уничтожения массива имеет следующую форму:

delete[] str1;

Пустые квадратные скобки необходимы. Они говорят компилятору, что указатель адресует массив, а не единичный элемент. Поскольку тип str1 – указатель на char, без этих скобок компилятор не поймет, что удалять следует целый массив.

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

Чтобы избежать проблем, связанных с управлением динамически выделяемой памятью для массивов, рекомендуется пользоваться контейнерными типами из стандартной библиотеки, такими, как vector, list или string. Они управляют памятью автоматически. (Тип string был представлен в разделе 3.4, тип vector – в разделе 3.10. Подробное описание контейнерных типов см. в главе 6.)

Динамическое выделение памяти и указатели

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

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

До сих пор во всех наших примерах использовалось статическое выделение памяти. Скажем, определение переменной ival

int ival = 1024;

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

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

int ival2 = ival + 1;

то обращаемся к значению, содержащемуся в переменной ival: прибавляем к нему 1 и инициализируем переменную ival2 этим новым значением, 1025. Каким же образом обратиться к адресу, по которому размещена переменная?

С++ имеет встроенный тип “указатель”, который используется для хранения адресов объектов. Чтобы объявить указатель, содержащий адрес переменной ival, мы должны написать:

int *pint; // указатель на объект типа int

Вторая форма оператора new выделяет память под массив заданного размера, состоящий из элементов определенного типа:

int *pia = new int[4];

В этом примере память выделяется под массив из четырех элементов типа int. К сожалению, данная форма оператора new не позволяет инициализировать элементы массива.

Некоторую путаницу вносит то, что обе формы оператора new возвращают одинаковый указатель, в нашем примере это указатель на целое. И pint, и pia объявлены совершенно одинаково, однако pint указывает на единственный объект типа int, а pia – на первый элемент массива из четырех объектов типа int.

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

// освобождение единичного объекта

delete pint;

// освобождение массива

delete[] pia;

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

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

Упражнение 2.3

Объясните разницу между четырьмя объектами:

(a) int ival = 1024;

(b) int *pi = &ival;

(c) int *pi2 = new int(1024);

(d) int *pi3 = new int[1024];

Упражнение 2.4

Что делает следующий фрагмент кода? В чем состоит логическая ошибка? (Отметим, что операция взятия индекса ([]) правильно применена к указателю pia. Объяснение этому факту можно найти в разделе 3.9.2.)

int *pi = new int(10);

int *pia = new int[10];

while ( *pi < 10 ) {

  pia[*pi] = *pi;

  *pi = *pi + 1;

}

delete pi;

delete[] pia;

Директива extern "C" и перегруженные функции *

В разделе 7.7 мы видели, что директиву связывания extern "C" можно использовать в программе на C++ для того, чтобы указать, что некоторый объект находится в части, написанной на языке C. Как эта директива влияет на объявления перегруженных функций? Могут ли в одном и том же множестве находиться функции, написанные как на C++, так и на C?

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

// ошибка: для двух перегруженных функций указана директива extern "C"

extern "C" void print( const char* );

extern "C" void print( int );

Приведенный ниже пример перегруженной функции calc() иллюстрирует типичное применение директивы extern "C":

class SmallInt ( /* ... */ );

class BigNum ( /* ... */ );

// написанная на C функция может быть вызвана как из программы,

// написанной на C, так и из программы, написанной на C++.

// функции C++ обрабатывают параметры, являющиеся классами

extern "C" double calc( double );

extern SmallInt calc( const SmallInt& );

extern BigNum calc( const BigNum& );

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

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

Smallint si = 8;

int main() {

   calc( 34 );     // вызывается C-функция calc( double )

   calc( si );     // вызывается функция C++ calc( const SmallInt & )

   // ...

   return 0;

}

Директива связывания extern "C" *

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

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

в форме простой либо составной инструкции:

// директива связывания в форме простой инструкции

extern "C" void exit(int);

// директива связывания в форме составной инструкции

extern "C" {

    int printf( const char* ... );

    int scanf( const char* ... );

}

// директива связывания в форме составной инструкции

extern "C" {

#include <cmath>

}

Первая форма такой директивы состоит из ключевого слова extern, за которым следует строковый литерал, а за ним – “обычное” объявление функции. Хотя функция написана на другом языке, проверка типов вызова выполняется полностью. Несколько объявлений функций могут быть помещены в фигурные скобки составной инструкции директивы связывания – второй формы этой директивы. Скобки отмечают те объявления, к которым она относится, не ограничивая их видимости, как в случае обычной составной инструкции. Составная инструкция extern "C" в предыдущем примере говорит только о том, что функции printf() и scanf() написаны на языке С. Во всех остальных отношениях эти объявления работают точно так же, как если бы они были расположены вне инструкции.

Если в фигурные скобки составной директивы связывания помещается директива препроцессора #include, все объявленные во включаемом заголовочном файле функции рассматриваются как написанные на языке, указанном в этой директиве. В предыдущем примере все функции из заголовочного файла cmath написаны на языке С.

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

int main() {

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

    // внутри тела функции

    extern "C" double sqrt( double );

    double getValue(); //правильно

    double result = sqrt ( getValue() );

    //...

    return 0;

}

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

extern "C" double sqrt( double );

int main() {

    double getValue(); //правильно

    double result = sqrt ( getValue() );

    //...

    return 0;

}

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

Как сделать С++ функцию доступной для программы на С? Директива extern "C" поможет и в этом:

// функция calc() может быть вызвана из программы на C

extern "C" double calc( double dparm ) { /* ... */ }

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

// ---- myMath.h ----

extern "C" double calc( double );

// ---- myMath.C ----

// объявление calc() в myMath.h

#include "myMath.h"

// определение функции extern "C" calc()

// функция calc() может быть вызвана из программы на C

double calc( double dparm ) { // ... }

В данном разделе мы видели примеры директивы связывания extern "C" только для языка С. Это единственный внешний язык, поддержку которого гарантирует стандарт С++. Конкретная реализация может поддерживать связь и с другими языками. Например, extern "Ada" для функций, написанных на языке Ada; extern "FORTRAN" для языка FORTRAN и т.д. Мы описали один из случаев использования ключевого слова extern в С++. В разделе 8.2 мы покажем, что это слово имеет и другое назначение в объявлениях функций и объектов.

Упражнение 7.14

exit(), printf(), malloc(), strcpy() и strlen() являются функциями из библиотеки С. Модифицируйте приведенную ниже С-программу так, чтобы она компилировалась и связывалась в С++.

const char *str = "hello";

void *malloc( int );

char *strcpy( char *, const char * );

int printf( const char *, ... );

int exit( int );

int strlen( const char * );

int main()

{   /* программа на языке С */

    char* s = malloc( strlen(str)+l );

    strcpy( s, str );

    printf( "%s, world\n", s );

    exit( 0 );

}

Директива typedef

Директива typedef позволяет задать синоним для встроенного либо пользовательского типа данных. Например:

typedef double      wages;

typedef vector<int> vec_int;

typedef vec_int     test_scores;

typedef bool        in_attendance;

typedef int         *Pint;

Имена, определенные с помощью директивы typedef, можно использовать точно так же, как спецификаторы типов:

// double hourly, weekly;

wages hourly, weekly;

// vector<int> vecl( 10 );

vec_int vecl( 10 );

// vector<int> test0( c1ass_size );

const int c1ass_size = 34;

test_scores test0( c1ass_size );

// vector< bool > attendance;

vector< in_attendance > attendance( c1ass_size );

// int *table[ 10 ];

Pint table [ 10 ];

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

Для чего используются имена, определенные с помощью директивы typedef? Применяя мнемонические имена для типов данных, можно сделать программу более легкой для восприятия. Кроме того, принято употреблять такие имена для сложных составных типов, в противном случае воспринимаемых с трудом (см. пример в разделе 3.14), для объявления указателей на функции и функции-члены класса (см. раздел 13.6).

Ниже приводится пример вопроса, на который почти все дают неверный ответ. Ошибка вызвана непониманием директивы typedef как простой текстовой макроподстановки. Дано определение:

typedef char *cstring;

Каков тип переменной cstr в следующем объявлении:

extern const cstring cstr;

Ответ, который кажется очевидным:

const char *cstr

Однако это неверно. Спецификатор const относится к cstr, поэтому правильный ответ – константный указатель на char:

char *const cstr;

Директивы препроцессора

Заголовочные файлы включаются в текст программы с помощью директивы препроцессора

#include.  Директивы препроцессора начинаются со знака “диез” (#), который должен быть самым первым символом строки. Программа, которая обрабатывает эти директивы, называется препроцессором (в современных компиляторах препроцессор обычно является частью самого компилятора).

Директива #include включает в программу содержимое указанного файла. Имя файла может быть указано двумя способами:

#include <some_file.h>

#include "my_file.h"

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

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

#ifndef BOOKSTORE_H

#define BOOKSTORE_H

  /* содержимое файла bookstore.h */

#endif

Условная директива #ifndef проверяет, не было ли значение BOOKSTORE_H определено ранее. (BOOKSTORE_H – это константа препроцессора; такие константы принято писать заглавными буквами.) Препроцессор обрабатывает следующие строки вплоть до директивы #endif. В противном случае он пропускает строки от #ifndef до # endif.

Директива

#define BOOKSTORE_H

определяет константу препроцессора BOOKSTORE_H. Поместив эту директиву непосредственно после директивы #ifndef, мы можем гарантировать, что содержательная часть заголовочного файла bookstore.h будет включена в исходный текст только один раз, сколько бы раз ни включался в текст сам этот файл.

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

int main()

{

#ifdef DEBUG

  cout << "Начало выполнения main()\n";

#endif

  string word;

  vector<string> text;

  while ( cin >> word )

  {

#ifdef DEBUG

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

#endif

    text.push_back(word);

  }

  // ...

}

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

int main()

{

  string word;

  vector<string> text;

  while ( cin >> word )

  {

    text.push_back(word);

  }

  // ...

}

В противном случае мы получим:

int main()

{

  cout << "Начало выполнения main()\n";

  string word;

  vector<string> text;

  while ( cin >> word )

  {

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

    text.push_back(word);

  }

  // ...

}

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

$ CC -DDEBUG main.C

Есть константы, которые автоматически определяются компилятором. Например, мы можем узнать, компилируем ли мы С++ или С программу. Для С++ программы автоматически определяется константа __cplusplus (два подчеркивания). Для стандартного С определяется __STDC__. Естественно, обе константы не могут быть определены одновременно. Пример:

#idfef __cplusplus

  // компиляция С++ программы

  extern "C";

  // extern "C" объясняется в главе 7

#endif

int main(int,int);

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



if ( element_count == 0 )

  cerr << "Ошибка. Файл: " << __FILE__

       << " Строка: " << __LINE__

       << "element_count не может быть 0";

Две константы __DATE__ и __TIME__ содержат дату и время компиляции.

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

#include <assert.h>

assert.h – это заголовочный файл стандартной библиотеки С. Программа на C++ может ссылаться на заголовочный файл как по его имени, принятому в C, так и по имени, принятому в C++. В стандартной библиотеке С++ этот файл носит имя cassert. Имя заголовочного файла в библиотеке С++ отличается от имени соответствующего файла для С отсутствием расширения .h и подставленной спереди буквой c (выше уже упоминалось, что в заголовочных файлах для C++ расширения не употребляются, поскольку они могут зависеть от реализации).

Эффект от использования директивы препроцессора #include зависит от типа заголовочного файла. Инструкция

#include <cassert>

включает в текст программы содержимое файла cassert. Но поскольку все имена, используемые в стандартной библиотеке С++, определены в пространстве std, имя assert() будет невидимо до тех пор, пока мы явно не сделаем его видимым с помощью следующей using-директивы:

using namespace std;

Если же мы включаем в программу заголовочный файл для библиотеки С

#include <assert.h>

то надобность в using-директиве отпадает: имя assert() будет видно и так[2]. (Пространства имен используются разработчиками библиотек для предотвращения засорения глобального пространства имен. В разделе 8.5 эта тема рассматривается более подробно.)

Дополнительные операции со строками

Вторая форма функции-члена erase() принимает в качестве параметров два итератора, ограничивающих удаляемую подстроку. Например, превратим

string name( "AnnaLiviaPlurabelle" );

в строку "Annabelle":

typedef string::size_type size_type;

size_type startPos = name.find( 'L' )

size_type endPos   = name.find_1ast_of( 'b' );

name.erase( name.begin()+startPos,

            name.begin()+endPos );

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

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

name.erase( name. begin()+4 );

оставляет строку "Anna".

Функция-член insert() позволяет вставить в заданную позицию строки другую строку или символ. Общая форма выглядит так:

string_object.insert( position, new_string );

position обозначает позицию, перед которой производится вставка. new_string может быть объектом класса string, C-строкой или символом:

string string_object( "Missisippi" );

string::size_type pos = string_object.find( "isi" );

string_object.insert( pos+1, 's' );

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

string new_string ( "AnnaBelle Lee" );

string_object += ' '; // добавим пробел

// найдем начальную и конечную позицию в new_string

pos = new_string.find( 'B' );

string::size_type posEnd = new_string.find( ' ' );

string_object.insert(

    string_object.size(), // позиция вставки

    new_string, pos,      // начало подстроки в new_string

    posEnd                // конец подстроки new_string

)

string_object получает значение "Mississippi Belle". Если мы хотим вставить все символы new_string, начиная с pos, последний параметр нужно опустить.

Пусть есть две строки:

string sl( "Mississippi" );

string s2( "Annabelle" );

Как получить третью строку со значением "Miss Anna"?

Можно использовать функции-члены assign() и append():

string s3;

// скопируем первые 4 символа s1

s3.assign ( s1, 4 );

s3 теперь содержит значение "Miss".

// добавим пробел

s3 += ' ';

Теперь s3 содержит "Miss ".

// добавим 4 первых символа s2

s3.append(s2,4);

s3 получила значение "Miss Anna". То же самое можно сделать короче:

s3.assign(s1,4).append(' ').append(s2,4);

Другая форма функции-члена assign() имеет три параметра: второй обозначает позицию начала, а третий – длину. Позиции нумеруются с 0. Вот как, скажем, извлечь "belle" из "Annabelle":

string beauty;

// присвоим beauty значение "belle"

beauty.assign( s2, 4, 5 );

Вместо этих параметров мы можем использовать пару итераторов:

// присвоим beauty значение "belle"

beauty.assign( s2, s2.begin()+4, s2.end() );

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

string current_project( "C++ Primer, 3rd Edition" );

string pending_project( "Fantasia 2000, Firebird segment" );

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

current_project.swap( pending_project );

Для строки

string first_novel( "V" );

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

char ch = first_novel[ 1 ];

возвратит неопределенное значение: длина строки first_novel равна 1, и единственное правильное значение индекса – 0. Такая операция взятия индекса не обеспечивает проверку правильности параметра, но мы всегда можем сделать это сами с помощью функции-члена size():

int

elem_count( const string &word, char elem )

{

    int occurs = 0;

    // не надо больше проверять ix

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

        if ( word[ ix ] == elem )

           ++occurs;

    return occurs;

}

Там, где это невозможно или нежелательно, например:

void

mumble( const string &st, int index )



{

    // возможна ошибка

    char ch = st[ index ];

    // ...

}

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

void

mumble( const string &st, int index )

{

    try {

        char ch = st.at( index );

        // ...

    }

    catch ( std::out_of_range ){...}

    // ...

}

Строки можно сравнивать лексикографически. Например:

string cobol_program_crash( "abend" );

string cplus_program_crash( "abort" );

Строка cobol_program_crash лексикографически меньше, чем cplus_program_crash: сопоставление производится по первому отличающемуся символу, а буква e в латинском алфавите идет раньше, чем o. Операция сравнения выполняется функцией-членом compare(). Вызов

sl.compare( s2 );

возвращает одно из трех значений:

если s1 больше, чем s2, то положительное;

если s1 меньше, чем s2, то отрицательное;

если s1 равно s2, то 0.

Например,

cobol_program_crash.compare( cplus_program_crash );

вернет отрицательное значение, а

cplus_program_crash.compare( cobol_program_crash );

положительное. Перегруженные операции сравнения (<, >, !=, ==, <=, >=) являются более компактной записью функции compare().

Шесть вариантов функции-члена compare() позволяют выделить сравниваемые подстроки в одном или обоих операндах. (Примеры вызовов приводились в предыдущем разделе.)

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

string sentence(

    "An ADT provides both interface and implementation." );

string::size_type position = sentence.find_1ast_of( 'A' );

string::size_type length = 3;

// заменяем ADT на Abstract Data Type



sentence.repiace( position, length, "Abstract Data Type" );

position представляет собой начальную позицию, а length – длину заменяемой подстроки. Третий аргумент является подставляемой строкой. Его можно задать несколькими способами. Допустим, как объект string:

string new_str( "Abstract Data Type" );

sentence.replace( position, length, new_str );

Следующий пример иллюстрирует выделение подстроки в new_str:

#include <string>

typedef string::size_type size_type;

// найдем позицию трех букв

size_type posA = new_str.find( 'A' );

size_type posD = new_str.find( 'D' );

size_type posT = new_str.find( 'T' );

// нашли: заменим T на "Type"

sentence.replace( position+2, 1, new_str, posT, 4 );

// нашли: заменим D на "Data "

sentence.replace( position+1, 1, new_str, posD, 5 );

// нашли: заменим A на "Abstract "

sentence.replace( position, 1, new_str, posA, 9 );

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

string hmm( "Some celebrate Java as the successor to C++." );

string:: size_type position = hmm.find( 'J' );

// заменим Java на xxxx

hmm.repiace( position, 4, 'x', 4 );

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

const char *lang = "EiffelAda95JavaModula3";

int index[] = { 0, 6, 11, 15, 22 };

string ahhem(

     "C++ is the language for today's power programmers." );

ahhem.replace(0, 3, lang+index[1], index[2]-index[1]);

А здесь мы используем пару итераторов:

string sentence(

    "An ADT provides both interface and implementation." );

// указывает на 'A' в ADT

string: iterator start = sentence. begin()+3;

// заменяем ADT на Abstract Data Type

sentence.repiace( start, start+3, "Abstract Data Type" );

Оставшиеся четыре варианта допускают задание заменяющей строки как объекта типа string, символа, повторяющегося N раз, пары итераторов и C-строки.



Вот и все, что мы хотели сказать об операциях со строками. Для более полной информации обращайтесь к определению стандарта С++ [ISO-C++97].

Упражнение 6.18

Напишите программу, которая с помощью функций-членов assign() и append() из строк

string quote1( "When lilacs last in the dooryard bloom'd" );

string quote2( "The child "is father of the man" );

составит предложение

"The child is in the dooryard"

Упражнение 6.19

Напишите функцию:

string generate_salutation( string generic1,

                            string lastname,

                            string generic2,

                            string::size_type pos,

                            int length );

которая в строке

string generic1( "Dear Ms Daisy:" );

заменяет Daisy и Ms (миссис). Вместо Daisy подставляется параметр lastname, а вместо Ms подстрока

string generic2( "MrsMsMissPeople" );

длины length, начинающаяся с pos.

Например, вызов

string lastName( "AnnaP" );

string greetings =

    generate_salutation( generici, lastName, generic2, 5, 4 );

вернет строку:

Dear Miss AnnaP:

Дополнительные операторы ввода/вывода

Иногда необходимо прочитать из входного потока последовательность не интерпретируемых байтов, а типов данных, таких, как char, int, string и т.д. Функция-член get() класса istream читает по одному байту, а функция getline() читает строку, завершающуюся либо символом перехода на новую строку, либо каким-то иным символом, определяемым пользователем. У функции-члена get() есть три формы:

get(char& ch) читает из входного потока один символ (в том числе и пустой) и помещает его в ch. Она возвращает объект iostream, для которого была вызвана. Например, следующая программа собирает статистику о входном потоке, а затем копирует входной поток в выходной:

#include <iostream>

int main()

{

   char ch;

   int  tab_cnt = 0, nl_cnt = 0, space_cnt = 0,

        period_cnt = 0, comma_cnt = 0;

   while ( cin.get(ch)) {

           switch( ch ) {

                     case ' ':  space_cnt++;  break;

                     case '\t': tab_cnt++;    break;

                     case '\n': nl_cnt++;     break;

                     case '.':  period_cnt++; break;

                     case ',':  comma_cnt++;  break;

            }

            cout.put(ch);

   }

   cout << "\nнаша статистика:\n\t"

        << "пробелов: "    << space_cnt  << '\t'

        << "символов новой строки: " << nl_cnt     << '\t'

        << "табуляций: "      << tab_cnt    << "\n\t"

        << "точек: "   << period_cnt << '\t'

        << "запятых: "    << comma_cnt  << endl;

}

Функция-член put() класса ostream дает альтернативный метод вывода символа в выходной поток: put() принимает аргумент типа char и возвращает объект класса ostream, для которого была вызвана.

После компиляции и запуска программа печатает следующий результат:

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 creature,"

she tells him, at the same time wanting him to tell her more.

Shyly, she asks, "I mean, Daddy, is there?"

наша статистика:

       пробелов: 59      символов новой строки: 6     табуляций: 0

       точек: 4          запятых: 12

вторая форма get() также читает из входного потока по одному символу, но возвращает не поток istream, а значение прочитанного символа. Тип возвращаемого значения равен int, а не char, поскольку необходимо возвращать еще и признак конца файла, который обычно равен -1, чтобы отличаться от кодов реальных символов. Для проверки на конец файла мы сравниваем полученное значение с константой EOF, определенной в заголовочном файле iostream. Переменная, в которой сохраняется значение, возвращенное get(), должна быть объявлена как int, чтобы в ней можно было представить не только код любого символа, но и EOF:

#include <iostream>

int main()

{

      int ch;

      // альтернатива:

     // while ( ch = cin.get() && ch != EOF )

      while (( ch = cin.get()) != EOF )

              cout.put( ch );

      return 0;

}

При использовании любой из этих форм get() для чтения данной последовательности нужно семь итераций:

a b c

d

Читаются следующие символы: ('a', пробел, 'b', пробел, 'c', символ новой строки, 'd'). На восьмой итерации читается EOF. Оператор ввода (>>) по умолчанию пропускает пустые символы, поэтому на ту же последовательность потребуется четыре итерации, на которых возвращаются символы: 'a', 'b', 'c', 'd'. А вот следующая форма get() может прочесть всю последовательность всего за две итерации;

сигнатура третьей формы get() такова:

get(char *sink, streamsize size, char delimiter='\n')

sink – это массив, в который помещаются символы. size – это максимальное число символов, читаемых из потока istream. delimiter – это символ-ограничитель, при обнаружении которого чтение прекращается. Сам ограничитель не читается, а оставляется в потоке и будет прочитан следующим. Программисты часто забывают удалить его из потока перед вторым обращением к get(). Чтобы избежать этой ошибки, в показанной ниже программе мы воспользовались функцией-членом ignore() класса istream. По умолчанию ограничителем является символ новой строки.



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

прочитано size-1 символов;

встретился конец файла;

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

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

#include <iostream>

int main()

{

      const int max_line = 1024;

      char line[ max_line ];

      while ( cin.get( line, max_line ))

      {

            // читается не больше max_line - 1 символов,

            // чтобы оставить место для нуля

            int get_count = cin.gcount();

            cout << "фактически прочитано символов: "

                 << get_count << endl;

            // что-то сделать со строкой

            // если встретился символ новой строки,

            // удалить его, прежде чем приступать к чтению следующей

            if ( get_count < max_line-1 )

              cin.ignore();

      }

}

Если на вход этой программы подать текст о юной Алисе Эмме, то результат будет выглядеть так:

фактически прочитано символов: 52

фактически прочитано символов: 60

фактически прочитано символов: 66

фактически прочитано символов: 63

фактически прочитано символов: 61

фактически прочитано символов: 43

Чтобы еще раз протестировать поведение программы, мы создали строку, содержащую больше max_line символов, и поместили ее в начало текста. Получили:

фактически прочитано символов: 1023

фактически прочитано символов: 528

фактически прочитано символов: 52

фактически прочитано символов: 60

фактически прочитано символов: 66

фактически прочитано символов: 63

фактически прочитано символов: 61

фактически прочитано символов: 43

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



ignore( streamsize length = 1, int delim = traits::eof )

ignore() читает и отбрасывает length символов из потока или все символы до ограничителя включительно или до конца файла и возвращает объект istream, для которого вызвана.

Мы рекомендуем пользоваться функцией getline(), а не get(), поскольку она автоматически удаляет ограничитель из потока. Сигнатура getline() такая же, как у get() с тремя аргументами (и возвращает она тоже объект istream, для которого вызвана):

getline(char *sink, streamsize size, char delimiter='\n')

Поскольку и getline(), и get() с тремя аргументами могут читать size символов или меньше, то часто нужно “спросить” у объекта istream, сколько символов было фактически прочитано. Это позволяет сделать функция-член gcount(): она возвращает число символов, прочитанных при последнем обращении к get() или getline().

Функция-член write() класса ostream дает альтернативный метод вывода массива символов. Вместо того чтобы выводить символы до завершающего нуля, она выводит указанное число символов, включая и внутренние нули, если таковые имеются. Вот ее сигнатура:

write( const char *sink, streamsize length )

Здесь length определяет, сколько символов выводить. write() возвращает объект класса ostream, для которого она вызвана.

Парной для функции write() из класса ostream является функция read() из класса istream с такой сигнатурой:

read( char* addr, streamsize size )

read() читает size соседних байт из входного потока и помещает их, начиная с адреса addr. Функция gcount() возвращает число байт, прочитанных при последнем обращении к read(). В свою очередь read() возвращает объект класса istream, для которого она вызвана. Вот пример использования getline(), gcount() и write():

#include <iostream>

int main()

{

           const int lineSize = 1024;

           int lcnt = 0; // сколько строк прочитано

           int max = -1; // длина самой длинной строки

           char inBuf[ lineSize ];

           // читается до конца строки, но не более 1024 символов



           while (cin.getline( inBuf, lineSize ))

           {

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

                  int readin = cin.gcount();

                  // статистика: счетчик строк, самая длинная строка

                  ++lcnt;

                  if ( readin > max )

              max = readin;

                  cout << "Строка #" << lcnt

                       << "\tПрочитано символов: " << readin << endl;

                  cout.write( inBuf, readin).put('\n').put('\n');

           }

           cout << "Всего прочитано строк: " << lcnt << endl;

           cout << "Самая длинная строка: " << max << endl;

}

Когда на вход было подано несколько фраз из романа Германа Мелвилла “Моби Дик”, программа напечатала следующее:

Строка #1 Прочитано символов: 45

Call me Ishmael.  Some years ago, never mind

Строка #2 Прочитано символов: 46

how long precisely, having little or no money

Строка #3 Прочитано символов: 48

in my purse, and nothing particular to interest

Строка #4 Прочитано символов: 51

me on shore, I thought I would sail about a little

Строка #5 Прочитано символов: 47

and see the watery part of the world.  It is a

Строка #6 Прочитано символов: 43

way I have of driving off the spleen, and

Строка #7 Прочитано символов: 28

regulating the circulation.

Всего прочитано строк: 7

Самая длинная строка: 51

Функция-член getline() класса istream поддерживает только ввод в массив символов. Однако в стандартной библиотеке есть обычная функция getline(), которая помещает символы в объект класса string:

getline( istream &is, string str, char delimiter );

Эта функция читает не более str::max_size()-1 символов. Если входная последовательность длиннее, то операция завершается неудачно и объект переводится в ошибочное состояние. В противном случае ввод прекращается, когда прочитан ограничитель (он удаляется из потока, но в строку не помещается) либо достигнут конец файла.



Вот еще три необходимые нам функции-члена класса istream:

// возвращает символ в поток

putback( char class );

// устанавливает "указатель на следующий символ потока istream на один символ назад

unget();

// возвращает следующий символ (или EOF),

// но не извлекает его из потока

peek();

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

char ch, next, lookahead;

while ( cin.get( ch ))

{

   switch (ch) {

   case '/':

      // это комментарий? посмотрим с помощью peek()

      // если да, пропустить остаток строки

      next = cin.peek();

      if ( next == '/' )

         cin.ignore( lineSize, '\n' );

      break;

   case '>':

      // проверка на лексему >>=

      next = cin.peek();

      if ( next == '>' ) {

         lookahead = cin.get();

         next = cin.peek();

         if ( next != '=' )

            cin.putback( lookahead );

         }

         // ...

}

Упражнение 20.4

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

a  b c

d     e

f

Упражнение 20.5

Прочитайте фразу “riverrun, from bend of bay to swerve of shore” сначала как последовательность из девяти строк, а затем как одну строку.

Упражнение 20.6

С помощью функций getline() и gcount() прочитайте последовательность строк из стандартного ввода и найдите самую длинную (не забудьте, что строку, прочитанную за несколько обращений к getline(), нужно считать одной).

Доступ к членам

Часто бывает так, что внутреннее представление типа класса изменяется в последующих версиях программы. Допустим, опрос пользователей нашего класса Screen показал, что для его объектов всегда задается размер экрана 80 ´ 24. В таком случае было бы желательно заменить внутреннее представление экрана менее гибким, но более эффективным:

class Screen {

public:

   // функции-члены

private:

   // инициализация статических членов (см. 13.5)

   static const int   _height = 24;

   static const int   _width = 80;

   string             _screen;

   string::size_type  _cursor;

};

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

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

все функции, которые напрямую обращались к данным-членам старого представления, перестали бы работать. Следовательно, пришлось бы отыскивать и изменять соответствующие части кода;

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

Сокрытие информации– это формальный механизм, предотвращающий прямой доступ к внутреннему представлению типа класса из функций программы. Ограничение доступа к членам задается с помощью секций тела класса, помеченных ключевыми словами public, private и protected –  спецификаторами доступа. Члены, объявленные в секции public, называются открытыми, а объявленные в секциях private и protected соответственно закрытыми или защищенными.

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

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

защищенный член ведет себя как открытый по отношению к производному классу и как закрытый по отношению к остальной части программы. (В главе 2 мы видели пример использования защищенных членов в классе IntArray. Детально они рассматриваются в главе 17, где вводится понятие наследования.)

В следующем определении класса Screen указаны секции public и private:

class Screen {

public:

   void home() { _cursor = 0; }

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

   char get( int, int );

   void move( int, int );

   // ...

private:

   string             _screen;

   string::size_type  _cursor;

   short              _height, _width;

};

Согласно принятому соглашению, сначала объявляются открытые члены класса. (Обсуждение того, почему в старых программах C++ сначала шли закрытые члены и почему этот стиль еще кое-где сохранился, см. в книге [LIPPMAN96a].) В теле класса может быть несколько секций public, protected и private. Каждая секция продолжается либо до метки следующей секции, либо до закрывающей фигурной скобки. Если спецификатор доступа не указан, то секция, непосредственно следующая за открывающей скобкой, по умолчанию считается private.

Доступ к членам базового класса

Объект производного класса фактически построен из нескольких частей. Каждый базовый класс вносит свою долю в виде подобъекта, составленного из нестатических данных-членов этого класса. Объект производного класса построен из подобъектов, соответствующих каждому из его базовых, а также из части, включающей нестатические члены самого производного класса. Так, наш объект NameQuery состоит из подобъекта Query, содержащего члены _loc и _solution, и части, принадлежащей NameQuery,– она содержит только член _name.

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

void

NameQuery::

display_partial_solution( ostream &os )

{

   os << _name

      << " is found in "

      << (_solution ? _solution->size() : 0)

      << " lines of text\n";

}

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

NameQuery nq( "Frost" );

// вызывается NameQuery::eval()

nq.eval();

// вызывается Query::display()

nq.display();

либо непосредственно из тела другой (или той же самой) функции-члена:

void

NameQuery::

match_count()

{

   if ( ! _solution )

      // вызывается Query::_vec2set()

      _solution = _vec2set( &_loc );

   return _solution->size();

}

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

class Diffident {

public:  // ...

protected:

   int _mumble;

   // ...

};

class Shy : public Diffident {

public: // ...

protected:

   // имя Diffident::_mumble скрыто

   string _mumble;

   // ...

};

В области видимости Shy употребление неквалифицированного имени _mumble разрешается в пользу члена _mumble класса Shy (объекта string), даже если такое использование в данном контексте недопустимо:

void

Shy::

turn_eyes_down()

{

   // ...

   _mumble = "excuse me";   // правильно

   // ошибка: int Diffident::_mumble скрыто

   _mumble = -1;

}

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

void

Shy::

turn_eyes_down()

{

   // ...

   _mumble = "excuse me";   // правильно

   // правильно: имя члена базового класса квалифицировано

   Diffident::_mumble = -1;

}

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

class Diffident {

public:

   void mumble( int softness );

   // ...

};

class Shy : public Diffident {

public:

   // скрывает видимость функции-члена Diffident::_mumble,

   // а не перегружает ее

   void mumble( string whatYaSay );

   void print( int soft, string words );

   // ...

};

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

Shy simon;

// правильно: Shy::mumble( string )

simon.mumble( "pardon me" );

// ошибка: ожидался первый аргумент типа string

// Diffident::mumble( int ) невидима

simon.mumble( 2 );

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

class Diffident {

public:

   void turn_aside( );

   // ...

};

class Shy : public Diffident {

public:

   // скрывает видимость

   // Diffident::turn_aside()

   void turn_aside();

   // ...

};

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



А если нам действительно нужен набор перегруженных функций-членов базового и производного классов? Написать в производном классе небольшую встроенную заглушку для вызова экземпляра из базового? Это возможно:

class Shy : public Diffident {

public:

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

   // членов базового и производного классов

   void mumble( string whatYaSay );

   void mumble( int softness ) {

                Diffident::mumble( softness ); }

   // ...

};

Но в стандартном C++  тот же результат достигается посредством using-объявления:

class Shy : public Diffident {

public:

   // в стандартном C++ using-объявление

   // создает множество перегруженных

   // членов базового и производного классов

   void mumble( string whatYaSay );

   using Diffident::mumble;

   // ...

};

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

Обратим внимание на степень доступности защищенных членов базового класса. Когда мы пишем:

class Query {

public:

   const vector<location>* locations() { return &_loc; }

   // ...

protected:

   vector<location> _loc;

   // ...

};

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



bool

NameQuery::

compare( const Query *pquery )

{

   // правильно: защищенный член подобъекта Query

   int myMatches = _loc.size();

   // ошибка: нет прав доступа к защищенному члену

   // независимого объекта Query

   int itsMatches = pquery->_loc.size();

   return myMatches == itsMatches;

}

У объекта NameQuery есть доступ к защищенным членам только одного объекта Query – подобъекта самого себя. Прямое обращение к ним из производного класса осуществляется через неявный указатель this (см. раздел 13.4). Первая реакция на ошибку компиляции – переписать функцию compare() с использованием открытой функции-члена location():

bool

NameQuery::

compare( const Query *pquery )

{

   // правильно: защищенный член подобъекта Query

   int myMatches = _loc.size();

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

   int itsMatches = pquery->locations()->size();

   return myMatches == itsMatches;

}

Однако проблема заключается в неправильном проектировании. Поскольку _loc – это член базового класса Query, то место compare() среди членов базового, а не производного класса. Во многих случаях подобные проблемы могут быть решены путем переноса некоторой операции в тот класс, где находится недоступный член, как в приведенном примере.

Этот вид ограничения доступа не распространяется на доступ изнутри класса к другим объектам того же класса:

bool

NameQuery::

compare( const NameQuery *pname )

{

   int myMatches = _loc.size();   // правильно

   int itsMatches = name->_loc.size();   // тоже правильно

   return myMatches == itsMatches;

}

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

Рассмотрим инициализацию указателя на базовый Query адресом объекта производного NameQuery:

Query *pb = new NameQuery( "sprite" );

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



pb->eval();  // вызывается NameQuery::eval()

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

a)    если в Query и NameQuery объявлены некоторые невиртуальные функции-члены с одинаковым именем, то через pb всегда вызывается экземпляр из Query;

b)   если в Query и NameQuery объявлены одноименные члены, то через pb обращение происходит к члену класса Query;

c)    если в NameQuery имеется виртуальная функция, отсутствующая в Query, скажем suffix(), то попытка вызвать ее через pb приводит к ошибке компиляции:

// ошибка: suffix() - не член класса Query

pb->suffix();

Обращение к члену или невиртуальной функции-члену класса NameQuery через pb тоже вызывает ошибку компиляции:

// ошибка: _name - не член класса Query

pb->_name;

Квалификация имени члена в этом случае не помогает:

// ошибка: у класса Query нет базового класса NameQuery

pb->NameQuery::_name;

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

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

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

механизм виртуализации можно оптимизировать. Часто вызов такой функции оказывается не дороже, чем косвенный вызов функции по указателю (детально этот вопрос рассмотрен в [LIPPMAN96a]).



В базовом классе Query определен статический член _text_file:

static vector<string> *_text_file;

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

nameQueryObject._text_file;   // правильно

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

class Query {

   friend class NameQuery;

public:

   // ...

};

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

А если мы произведем от NameQuery класс StringQuery? Он будет поддерживать сокращенную форму запроса AndQuery, и вместо

beautiful && fiery && bird

можно будет написать:

"beautiful fiery bird"

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

Упражнение 17.6

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

class Base {

public:

   foo( int );

   // ...

protected:

   int _bar;

   double _foo_bar;

};

class Derived : public Base {

public:

   foo( string );

   bool bar( Base *pb );

   void foobar();

   // ...

protected:

   string _bar;

};

Исправьте ошибки в каждом из следующих фрагментов кода:

Derived d; d.foo( 1024 );

 (b) void Derived::foobar() { _bar = 1024; }

(c) bool Derived::bar( Base *pb )

         { return _foo_bar == pb->_foo_bar; }

Доступ к членам класса

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

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

когда функция-член обращается к членам класса, операторы доступа “точка” и “стрелка” не необходимы.

Например:

#include <string>

void Screen::copy( const Screen &sobj )

{

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

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

   // мы анализируем указатель this (см. раздел 13.4)

   if ( this != &sobj )

   {

      _height = sobj._height;

      _width = sobj._width;

      _cursor = 0;

      // создаем новую строку;

      // ее содержимое такое же, как sobj._screen

      _screen = sobj._screen;

   }

}

Хотя _screen, _height, _width и _cursor являются закрытыми членами класса Screen, функция-член copy() работает с ними напрямую. Если при обращении к члену отсутствует оператор доступа, то считается, что речь идет о члене того класса, для которого функция-член вызвана. Если вызвать copy() следующим образом:

#include "Screen.h"

int main()

{

   Screen s1;

   // Установить s1

   Screen s2;

   s2.copy(s1);

   // ...

}

то параметр sobj внутри определения copy() соотносится с объектом s1 из функции main(). Функция-член copy() вызвана для объекта s2, стоящего перед оператором “точка”. Для такого вызова члены _screen, _height, _width и _cursor, при обращении к которым внутри определения этой функции нет оператора доступа, – это члены объекта s2. В следующем разделе мы рассмотрим доступ к членам класса внутри определения функции-члена более подробно и, в частности, покажем, как для поддержки такого доступа применяется указатель this.

Друзья

Иногда удобно разрешить некоторым функциям доступ к закрытым членам класса. Механизм друзей

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

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

class Screen {

   friend istream&

      operator>>( istream&, Screen& );

   friend ostream&

      operator<<( ostream&, const Screen& );

public:

   // ... оставшаяся часть класса Screen

};

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

#include <iostream>

ostream& operator<<( ostream& os, const Screen& s )

{

   // правильно: можно обращаться к _height, _width и _screen

   os << "<" << s._height

      << "," << s._width << ">";

   os << s._screen;

   return os;

}

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

Друзья

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

bool operator==( const String &str1, const String &str2 )

{

   if ( str1.size() != str2.size() )

      return false;

   return strcmp( str1.c_str(), str2.c_str() ) ? false : true;

}

Сравните это определение с определением того же оператора как функции-члена:

bool String::operator==( const String &rhs ) const

{

   if ( _size != rhs._size )

      return false;

   return strcmp( _string, rhs._string ) ? false : true;

}

Нам пришлось модифицировать способ обращения к закрытым членам класса String. Поскольку новый оператор равенства– это глобальная функция, а не функция-член, у него нет доступа к закрытым членам класса String. Для получения размера объекта String и лежащей в его основе C-строки символов используются функции-члены size() и c_str().

Альтернативной реализацией является объявление глобальных операторов равенства друзьями

класса String. Если функция или оператор объявлены таким образом, им предоставляется доступ к неоткрытым членам.

Объявление друга (оно начинается с ключевого слова friend) встречается только внутри определения класса. Поскольку друзья не являются членами класса, объявляющего дружественные отношения, то безразлично, в какой из секций – public, private или protected – они объявлены. В примере ниже мы решили поместить все подобные объявления сразу после заголовка класса:

class String {

   friend bool operator==( const String &, const String & );

   friend bool operator==( const char *, const String & );

   friend bool operator==( const String &, const char * );

public:

   // ... остальная часть класса String

};

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

// дружественные операторы напрямую обращаются к закрытым членам

// класса String

bool operator==( const String &str1, const String &str2 )

{

   if ( str1._size != str2._size )

      return false;

   return strcmp( str1._string, str2._string ) ? false : true;

}

inline bool operator==( const String &str, const char *s )

{

   return strcmp( str._string, s ) ? false : true;

}

// и т.д.

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

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

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

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



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

extern ostream& storeOn( ostream &, Screen & );

extern BitMap& storeOn( BitMap &, Screen & );

// ...

class Screen

{

   friend ostream& storeOn( ostream &, Screen & );

   friend BitMap& storeOn( BitMap &, Screen & );

   // ...

};

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

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

class Window;   // это всего лишь объявление

class Screen {

   friend bool is_equal( Screen &, Window & );

   // ...

};

class Window {

   friend bool is_equal( Screen &, Window & );

   // ...

};

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

class Window;

class Screen {

   // copy() - член класса Screen

   Screen& copy( Window & );

   // ...

};

class Window {

   // Screen::copy() - друг класса Window

   friend Screen& Screen::copy( Window & );

   // ...

};

Screen& Screen::copy( Window & ) { /* ... */ }

Функция-член одного класса не может быть объявлена другом второго, пока компилятор не увидел определения ее собственного класса. Это не всегда возможно. Предположим, что Screen должен объявить некоторые функции-члены Window своими друзьями, а Window – объявить таким же образом некоторые функции-члена Screen. В таком случае весь класс Window объявляется другом Screen:

class Window;

class Screen {

   friend class Window;

   // ...

};

К закрытым членам класса Screen теперь можно обращаться из любой функции-члена Window.

Упражнение 15.6

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

Еще раз о разрешении перегрузки функций

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

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

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

Еще раз об итераторах

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

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

template < typename type >

int

count( const vector< type > &vec, type value )

{

   int count = 0;

   vector< type >::iterator iter = vec.begin();

   while ( iter != vec.end() )

      if ( *iter == value )

         ++count;

   return count;

}

Проблема в том, что у ссылки vec есть спецификатор const, а мы пытаемся связать с ней итератор без такого спецификатора. Если бы это было разрешено, то ничто не помешало бы нам модифицировать с помощью этого итератора элементы вектора. Для предотвращения подобной ситуации язык требует, чтобы итератор, связанный с const-вектором, был константным. Мы можем сделать это следующим образом:

// правильно: это компилируется без ошибок

vector< type>::const_iterator iter = vec.begin();

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

Операции begin() и end() перегружены и возвращают константный или неконстантный итератор в зависимости от наличия спецификатора const в объявлении контейнера. Если дана такая пара объявлений:

vector< int > vec0;

const vector< int > vec1;

то при обращениях к begin() и end() для vec0 будет возвращен неконстантный, а для vec1 – константный итератор:

vector< int >::iterator iter0 = vec0.begin();

vector< int >::const_iterator iter1 = vec1.begin();

Разумеется, присваивание константному итератору неконстантного разрешено всегда. Например:

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

vector< int >::const_iterator iter2 = vec0.begin();

Файловый ввод/вывод

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

#include <fstream>

Перед тем как открыть файл для вывода, необходимо объявить объект типа ofstream:

ofstream outfile("name-of-file");

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

if ( ! outfile ) // false, если файл не открыт

   cerr << "Ошибка открытия файла.\n"

Так же открывается файл и для ввода, только он имеет тип ifstream:

ifstream infile("name-of-file");

if ( ! infile ) // false, если файл не открыт

   cerr << "Ошибка открытия файла.\n"

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

#include <iostream>

#include <fstream>

#include <string>

int main()

{

  ifstream infile("in_file");

  ofstream outfile("out_file");

  if ( ! infile ) {

    cerr << "Ошибка открытия входного файла.\n"

    return -1;

  }

  if ( ! outfile ) {

    cerr << "Ошибка открытия выходного файла.\n"

    return -2;

  }

  string word;

  while ( infile >> word )

    outfile << word << ' ';

  return 0;

}

В главе 20 библиотека ввода/вывода будет рассмотрена подробно. А в следующих разделах мы увидим, как можно создавать новые типы данных, используя механизм классов и шаблонов.

Файловый ввод/вывод

Если программе необходимо работать с файлом, то следует включить в нее заголовочный файл fstream (который в свою очередь включает iostream):

#include <fstream>

Если файл будет использоваться только для вывода, мы определяем объект класса ofstream. Например:

ofstream outfile( "copy.out", ios::base::out );

Передаваемые конструктору аргументы задают имя открываемого файла и режим открытия. Файл типа ofstream может быть открыт либо – по умолчанию – в режиме вывода (ios_base::out), либо в режиме дозаписи (ios_base::app). Такое определение файла outfile2 эквивалентно приведенному выше:

// по умолчанию открывается в режиме вывода

ofstream outfile2( "copy.out" );

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

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

if ( ! outfile ) { // открыть файл не удалось

   cerr << "не могу открыть "copy.out" для записи\n";

   exit( -1 );

}

Класс ofstream является производным от ostream. Все определенные в ostream операции применимы и к ofstream. Например, инструкции

char ch = ' ';

outFile.put( '1' ).put( ')' ).put( ch );

outFile << "1 + 1 = " << (1 + 1) << endl;

выводят в файл outFile последовательность символов:

1) 1 + 1 = 2

Следующая программа читает из стандартного ввода символы и копирует их в стандартный вывод:

#include <fstream>

int main()

{

    // открыть файл copy.out для вывода

    ofstream outFile( "copy.out" );

    if ( ! outFile ) {

        cerr << "Не могу открыть 'copy.out' для вывода\n";

        return -1;

    }

    char ch;

    while ( cin.get( ch ) )

               outFile.put( ch );

}

К объекту класса ofstream можно применять и определенные пользователем экземпляры оператора вывода. Данная программа вызывает оператор вывода класса WordCount из предыдущего раздела:

#include <fstream>

#include "WordCount.h"

int main()

{

    // открыть файл word.out для вывода

    ofstream oFile( "word.out" );

    // здесь проверка успешности открытия ...

    // создать и вручную заполнить объект WordCount

    WordCount artist( "Renoir" );

    artist.found( 7, 12 ); artist.found( 34, 18 );

    // вызывается оператор <<(ostream&, const WordCount&);

    oFile << artist;

}

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

#include <fstream>

#include <string>

int main()

{

    cout << "filename: ";

    string file_name;

    cin >> file_name;

    // открыть файл для ввода

    ifstream inFile( file_name.c_str() );

    if ( !inFile ) {

         cerr << "не могу открыть входной файл: "

              << file_name << " -- аварийный останов!\n";

         return -1;

    }

    char ch;

    while ( inFile.get( ch ))

            cout.put( ch );

}

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

#include <fstream>

#include <iterator>

#include <vector>

#include <algorithm>

template <class InputIterator>

void filter_string( InputIterator first, InputIterator last,

                    string filt_elems = string("\",?."))

{

    for ( ; first != last; first++ )



    {

       string::size_type pos = 0;

       while (( pos = (*first).find_first_of( filt_elems, pos ))

                   != string::npos )

             (*first).erase( pos, 1 );

    }

}

int main()

{

           ifstream infile( "alice_emma" );

           istream_iterator<string> ifile( infile );

           istream_iterator<string> eos;

           vector< string > text;

           copy( ifile, eos, inserter( text, text.begin() ));

           string filt_elems( "\",.?;:" );

           filter_string( text.begin(), text.end(), filt_elems );

           vector<string>::iterator iter;

           sort( text.begin(), text.end() );

           iter = unique( text.begin(), text.end() );

           text.erase( iter, text.end() );

          

           ofstream outfile( "alice_emma_sort" );

           iter = text.begin();

           for ( int line_cnt = 1; iter != text.end();

           ++iter, ++line_cnt )

           {

        outfile << *iter << " ";

        if ( ! ( line_cnt % 8 ))

           outfile << '\n';

           }

     outfile << endl;

}

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

A Alice Daddy Emma Her I Shyly a

alive almost asks at beautiful bird blows but

creature fiery flight flowing hair has he her

him in is it like long looks magical

mean more no red same says she shush

such tell tells the there through time to

untamed wanting when wind

Объекты классов ofstream и ifstream разрешено определять и без указания имени файла. Позже к этому объекту можно присоединить файл с помощью функции-члена open():

ifstream curFile;

// ...

curFile.open( filename.c_str() );

if ( ! curFile )  // открытие успешно?

   // ...

Чтобы закрыть файл (отключить от программы), вызываем функцию-член close():

#include <fstream>

const int fileCnt = 5;

string fileTabl[ fileCnt ] = {



    "Melville", "Joyce", "Musil", "Proust", "Kafka"

};

int main()

{

    ifstream inFile; // не связан ни с каким файлом

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

    {

        inFile.open( fileTabl[ix].c_str() );

        // ... проверить успешность открытия

        // ... обработать файл

        inFile.close();

    }

}

Объект класса fstream ( производного от iostream) может открывать файл для ввода или

вывода. В следующем примере файл word.out сначала считывается, а затем записывается с помощью объекта типа fstream. Созданный ранее в этом разделе файл word.out содержит объект WordCount:

#include <fstream>

#include "WordCount.h"

int main()

{

    WordCount wd;

    fstream file;

    file.open( "word.out", ios::in );

    file >> wd;

    file.close();

    cout << "Прочитано: " << wd << endl;

    // операция ios_base::out стерла бы текущие данные

    file.open( "word.out", ios::app );

    file << endl << wd << endl;

    file.close();

}

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

fstream io( "word.out", ios_base::in|ios_base::app );

Для задания нескольких режимов используется оператор побитового ИЛИ. Объект класса fstream можно позиционировать с помощью функций-членов seekg() или seekp(). Здесь буква g обозначает позиционирование для чтения (getting) символов (используется с объектом класса ofstream), а p – для записи (putting) символов (используется с объектом класса ifstream). Эти функции делают текущим тот байт в файле, который имеет указанное абсолютное или относительное смещение. У них есть два варианта:

// установить абсолютное смещение в файле

seekg( pos_type current_position )

// смещение от текущей позиции в том или ином направлении



seekg( off_type offset_position, ios_base::seekdir dir );

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

abc def ghi jkl

то вызов

io.seekg( 6 );

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

ios_base::beg – от начала файла;

ios_base::cur – от текущей позиции;

ios_base::end – от конца файла.

В следующем примере каждый вызов seekg() позиционирует файл на i-ую запись:

for ( int i = 0; i < recordCnt; ++i )

      readFile.ssekg( i * sizeof(Record), ios_base::beg );

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

readFile.seekg( -10, ios_base::cur );

Текущая позиция чтения в файле типа fstream возвращается любой из двух функций-членов tellg() или tellp(). Здесь 'p' означает запись (putting) и используется с объектом ofstream, а 'g' говорит о чтении (getting) и обслуживает объект ifstream:

// сохранить текущую позицию

ios_base::pos_type mark = writeFile.tellp();

// ...

if ( cancelEntry )

   // вернуться к сохраненной позиции

   writeFile.seekp( mark );

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

// эквивалентные вызовы seekg

readFile.seekg( readFile.tellg() + sizeof(Record) );

// данный вызов считается более эффективным

readFile.seekg( sizeof(Record), ios_base::cur );

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



abcd

efg

hi

j

Программа должна создать файл, модифицированный следующим образом:

abcd

efg

hi

j

5 9 12 14 24

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

#include <iostream>

#include <fstream>

main() {

    // открыть файл для ввода и дозаписи

    fstream inOut( "copy.out", ios_base::in|ios_base::app );

    int cnt = 0;   // счетчик байтов

    char ch;

    while ( inOut.get( ch ))

    {

        cout.put( ch ); // скопировать на терминал

        ++cnt;

        if ( ch == '\n' ) {

            inOut << cnt ;

            inOut.put( ' ' ); // пробел

        }

    }

    // вывести окончательное значение счетчика байтов

    inOut << cnt << endl;

    cout << "[ " << cnt << " ]" << endl;

    return 0;

}

inOut – это объект класса fstream, связанный с файлом copy.out, открытым для ввода и дозаписи. Если файл открыт в режиме дозаписи, то все новые данные записываются в конец.

При чтении любого (включая пробельные) символа, кроме конца файла, мы увеличиваем переменную cnt на 1 и копируем прочитанный символ на терминал, чтобы вовремя заметить ошибки в работе программы.

Встретив символ новой строки, мы записываем текущее значение cnt в inOut. Как только будет достигнут конец файла, цикл прекращается. Окончательное значение cnt выводится в файл и на экран.

Программа компилируется без ошибок и кажется правильной. Но если подать на вход несколько фраз из романа “Моби Дик” Германа Мелвилла:

Call me Ishmael.  Some years ago, never mind

how long precisely, having little or no money

in my purse, and nothing particular to interest

me on shore, I thought I would sail about a little

and see the watery part of the world.  It is a

way I have of driving off the spleen, and

regulating the circulation.

то получим такой результат:

 [ 0 ]

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



inOut.get( ch );

мы читаем конец файла, цикл while завершается и выводится значение 0.

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

inOut.seekg( 0 );

Запустим программу заново. На этот раз она печатает:

Call me Ishmael.  Some years ago, never mind

[ 45 ]

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

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

// запомнить текущую позицию

ios_base::pos_type mark = inOut.tellg();

inOut << cnt << sp;

inOut.seekg( mark );   // восстановить позицию

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

Дело в том, что inOut находится в состоянии “конец файла”, в котором операции ввода и вывода не

выполняются. Для решения проблемы необходимо сбросить это состояние с помощью функции-члена clear():

inOut.clear();   // обнулить флаги состояния

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

#include <iostream>

#include <fstream>

int main()

{

    fstream inOut( "copy.out", ios_base::in|ios_base::app );

    int cnt=0;

    char ch;

    inOut.seekg(0);

    while ( inOut.get( ch ))

    {

        cout.put( ch );

        cnt++;

        if ( ch == '\n' )

        {



            // запомнить текущую позицию

            ios_base::pos_type mark = inOut.tellg();

            inOut << cnt << ' ';

            inOut.seekg( mark ); // восстановить позицию

        }

    }

    inOut.clear();

    inOut << cnt << endl;

    cout << "[ " << cnt << " ]\n";

    return 0;

}

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

Упражнение 20.12

Пользуясь операторами вывода для класса Date, которые вы определили в упражнении 20.7, или для класса CheckoutRecord из упражнения 20.8 (см. раздел 20.4), напишите программу, позволяющую создать файл и писать в него.

Упражнение 20.13

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

Упражнение 20.14

Напишите программу для открытия файла, созданного в упражнении 20.12, для чтения и дозаписи. Выведите экземпляр класса Date или CheckoutRecord:

(a) в начало файла

(b) после второго из существующих объектов

(c) в конец файла

Функции

Мы рассмотрели, как объявлять переменные (глава 3), как писать выражения (глава 4) и инструкции (глава 5). Здесь мы покажем, как группировать эти компоненты в определения функций, чтобы облегчить их многократное использование внутри программы. Мы увидим, как объявлять и определять функции и как вызывать их, рассмотрим различные виды передаваемых параметров и обсудим особенности использования каждого вида. Мы расскажем также о различных видах значений, которые может вернуть функция. Будут представлены четыре специальных случая применения функций: встроенные (inline), рекурсивные, написанные на других языках и объявленные директивами связывания, а также функция main(). В завершение главы мы разберем более сложное понятие – указатель на функцию.

Функции-члены

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

Функции-члены класса объявляются в его теле. Это объявление выглядит точно так же, как объявление функции в области видимости пространства имен. (Напомним, что глобальная область видимости – это тоже область видимости пространства имен. Глобальные функции рассматривались в разделе 8.2, а пространства имен – в разделе 8.5.) Например:

class Screen {

public:

   void home();

   void move( int, int );

   char get();

   char get( int, int );

   void checkRange( int, int );

   // ...

};

Определение функции-члена также можно поместить внутрь тела класса:

class Screen {

public:

   // определения функций home() и get()

   void home() { _cursor = 0; }

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

   // ...

};

home() перемещает курсор в левый верхний угол экрана; get() возвращает символ, находящийся в текущей позиции курсора.

Функции-члены отличаются от обычных функций следующим:

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

ptrScreen->home();

myScreen.home();

(в разделе 13.9 область видимости класса обсуждается более детально);

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

Функция-член может быть перегруженной (перегруженные функции рассматриваются в главе 9). Однако она способна перегружать лишь другую функцию-член своего класса. По отношению к функциям, объявленным в других классах или пространствах имен, функция-член находится в отдельной области видимости и, следовательно, не может перегружать их. Например, объявление get(int, int) перегружает лишь get() из того же класса Screen:

class Screen {

public:

   // объявления перегруженных функций-членов get()

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

   char get( int, int );

   // ...

};

(Подробнее мы остановимся на функциях-членах класса в разделе 13.3.)

Функции-члены класса

Функции-члены реализуют набор операций, применимых к объектам класса. Например, для Screen такой набор состоит из следующих объявленных в нем функций-членов:

class Screen {

public:

   void home() { _cursor = 0; }

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

   char get( int, int );

   void move( int, int );

   bool checkRange( int, int );

   int height() { return _height; }

   int width()  { return _width; }

   // ...

};

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

Screen myScreen, groupScreen;

myScreen.home();

groupScreen.home();

При вызове функции home() для объекта myScreen происходит обращение к его члену _cursor. Когда же эта функция вызывается для объекта groupScreen, то она обращается к члену _cursor именно этого объекта, причем сама функция home() одна и та же. Как же может одна функция-член обращаться к данным-членам разных объектов? Для этого применяется указатель this, рассматриваемый в следующем разделе.

Функции-члены шаблонов классов

Как и для обычных классов, функция-член шаблона класса может быть определена либо внутри определения шаблона (и тогда называется встроенной), либо вне его. Мы уже встречались со встроенными функциями-членами при рассмотрении шаблона Queue. Например, конструктор Queue является встроенным, так как определен внутри определения шаблона класса:

template <class Type>

class Queue {

   // ...

public:

   // встроенный конструктор

   Queue() : front( 0 ), back( 0 ) { }

   // ...

};

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

template <class Type>

class Queue {

public:

   Queue();

private:

   // ...

};

template <class Type>

inline Queue<Type>::

   Queue( ) { front = back = 0; }

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

Функция-член шаблона класса сама является шаблоном. Стандарт C++ требует, чтобы она конкретизировалась только при вызове либо при взятии ее адреса. (Некоторые более старые компиляторы конкретизируют такие функции одновременно с конкретизацией самого шаблона класса.) При конкретизации функции-члена используется тип того объекта, для которого функция вызвана:

Queue<string> qs;

Объект qs имеет тип Queue<string>. При инициализации объекта этого класса вызывается конструктор Queue<string>. В данном случае аргументом, которым конкретизируется функция-член (конструктор), будет string.

Функция-член шаблона конкретизируется только при реальном использовании в программе (т.е. при вызове или взятии ее адреса). От того, в какой именно момент конкретизируется функция-член, зависит разрешение имен в ее определении (см. раздел 16.11) и объявление ее специализации (см. раздел 16.9).

Функции-члены шаблонов Queue и QueueItem

Чтобы понять, как определяются и используются функции-члены шаблонов классов, продолжим изучение шаблонов Queue и 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;

};

Деструктор, а также функции-члены remove() и add() определены не в теле шаблона, а вне его. Деструктор Queue опустошает очередь:

template <class Type>

Queue<Type>::~Queue()

{

   while (! is_empty() )

      remove();

}

Функция-член Queue<Type>::add() помещает новый элемент в конец очереди:

template <class Type>

void Queue<Type>::add( const Type &val )

{

   // создать новый объект QueueItem

   QueueItem<Type> *pt =

      new QueueItem<Type>( val );

   if ( is_empty() )

      front = back = pt;

   else

   {

      back->next = pt;

      back = pt;

   }

}

Функция-член Queue<Type>::remove() возвращает значение элемента, находящегося в начале очереди, и удаляет сам элемент.

#include <iostream>

#include <cstdlib>

template <class Type>

Type Queue<Type>::remove()

{

   if ( is_empty() )

   {

      cerr << "remove() вызвана для пустой очереди\n";

      exit( -1 );

   }

   QueueItem<Type> *pt = front;

   front = front->next;

   Type retval = pt->item;

   delete pt;

   return retval;

}

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

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

#include <iostream>

#include "Queue.h"

int main()

{

   // конкретизируется класс Queue<int>

   // оператор new требует, чтобы Queue<int> был определен

   Queue<int> *p_qi = new Queue<int>;

   int ival;

   for ( ival = 0; ival < 10; ++ival )

      // конкретизируется функция-член add()

      p_qi->add( ival );

   int err_cnt = 0;

   for ( ival = 0; ival < 10; ++ival ) {

      // конкретизируется функция-член remove()

      int qval = p_qi->remove();

      if ( ival != qval ) err_cnt++;

   }

   if ( !err_cnt )

      cout << "!! queue executed ok\n";

   else cerr << "?? queue errors: " << err_cnt << endl;

   return 0;

}

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

!! queue executed ok

Упражнение 16.5

Используя шаблон класса Screen, определенный в разделе 16.2, реализуйте функции-члены Screen (см. разделы 13.3, 13.4 и 13.6) в виде функций-членов шаблона.

Функции-члены со спецификаторами const и volatile

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

const char blank = ' ';

blank = '\n';    // ошибка

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

const Screen blankScreen;

blankScreen.display();       // читает объект класса

blankScreen.set( '*' );      // ошибка: модифицирует объект класса

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

class Screen {

public:

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

   // ...

};

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

class Screen {

public:

   bool isEqual( char ch ) const;

   // ...

private:

   string::size_type  _cursor;

   string             _screen;

   // ...

};

bool Screen::isEqual( char ch ) const

{

   return ch == _screen[_cursor];

}

Запрещено объявлять константную функцию-член, которая модифицирует члены класса. Например, в следующем упрощенном определении:

class Screen {

public:

   int ok() const { return _cursor; }

   void error( int ival ) const { _cursor = ival; }

   // ...

private:

   string::size_type  _cursor;

   // ...

};

определение функции-члена ok() корректно, так как она не изменяет значения _cursor. В определении же error() значение _cursor изменяется, поэтому такая функция-член не может быть объявлена константной и компилятор выдает сообщение об ошибке:

error: cannot modify a data member within a const member function

ошибка: не могу модифицировать данные-члены внутри константной функции-члена

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

#include <cstring>

class Text {

public:

   void bad( const string &parm ) const;

private:

   char *_text;

};

void Text::bad( const string &parm ) const

{

   _text = parm.c_str();   // ошибка: нельзя модифицировать _text

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

       _text[ix] = parm[ix];   // плохой стиль, но не ошибка

}

Модифицировать _text нельзя, но это объект типа char*, и символы, на которые он указывает, можно изменить внутри константной функции-члена класса Text. Функция-член bad() демонстрирует плохой стиль программирования. Константность функции-члена не гарантирует, что объекты внутри класса останутся неизменными после ее вызова, причем компилятор не поможет обнаружить такую ситуацию.

Константную функцию-член можно перегружать неконстантной функцией с тем же списком параметров:

class Screen {

public:

   char get(int x, int y);

   char get(int x, int y) const;

   // ...

};

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

int main() {

   const Screen cs;

   Screen s;

   char ch = cs.get(0,0);   // вызывает константную функцию-член

   ch = s.get(0,0);         // вызывает неконстантную функцию-член

}

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

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

class Screen {

public:

   char poll() volatile;

   // ...

};

char Screen::poll() volatile { ... }

Функции-кандидаты

Функцией-кандидатом называется функция, имеющая то же имя, что и вызванная. Кандидаты отыскиваются двумя способами:

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

void f();

void f( int );

void f( double, double = 3.4 );

void f( char*, char* );

int main() {

   f( 5.6 );   // для разрешения этого вызова есть четыре кандидата

   return 0;

}

все четыре функции f() удовлетворяют этому условию. Поэтому множество кандидатов содержит четыре элемента;

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

namespace NS {

   class C { /* ... */ };

   void takeC( C& );

}

// тип cobj - это класс C, объявленный в пространстве имен NS

NS::C obj;

int main() {

                 // в точке вызова не видна ни одна из функций takeC()

   takeC( cobj); // правильно: вызывается NS::takeC( C& ),

                 // потому что аргумент имеет тип NS::C, следовательно,

                 // принимается во внимание функция takeC(),

                 // объявленная в пространстве имен NS

   return 0;

}

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

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

Функция, объявленная во вложенной области видимости, скрывает, а не перегружает одноименную функцию во внешней области. В такой ситуации кандидатами будут только функции из во вложенной области, т.е. такие, которые не скрыты при вызове. В следующем примере функциями-кандидатами, видимыми в точке вызова, являются format(double) и format(char*):

char* format( int );

void g() {

   char *format( double );

   char* format( char* );

   format(3);   // вызывается format( double )

}

Так как format(int), объявленная в глобальной области видимости, скрыта, она не включается в множество функций-кандидатов.

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

namespace libs_R_us {

   int max( int, int );

   double max( double, double );

}

char max( char, char );

void func()

{

   // функции из пространства имен невидимы

   // все три вызова разрешаются в пользу глобальной функции max( char, char )

   max( 87, 65 );

   max( 35.5, 76.6 );

   max( 'J', 'L' );

}

Функции max(), определенные в пространстве имен libs_R_us, невидимы в точке вызова. Единственной видимой является функция max() из глобальной области; только она входит в множество функций-кандидатов и вызывается при каждом из трех обращений к func(). Мы можем воспользоваться using-объявлением, чтобы сделать видимыми функции max() из пространства имен libs_R_us. Куда поместить using-объявление? Если включить его в глобальную область видимости:

char max( char, char );

using libs_R_us::max;   // using-объявление

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

void func()

{

   max( 87, 65 );     // вызывается libs_R_us::max( int, int )

   max( 35.5, 76.6 ); // вызывается libs_R_us::max( double, double )

   max( 'J', 'L' );   // вызывается ::max( char, char )

}

Но что будет, если мы введем using-объявление в локальную область видимости функции func(), как показано в данном примере?

void func()

{

   // using-объявление

   using libs_R_us::max;

   // те же вызовы функций, что и выше

}

Какие из функций max() будут включены в множество кандидатов? Напомним, что using-объявления вкладываются друг в друга. При наличии такого объявления в локальной области глобальная функция max(char, char) оказывается скрытой, так что в точке вызова видны только

Функции-кандидаты

Функцией-кандидатом называется функция с тем же именем, что и вызванная. Предположим, что имеется такой вызов:

SmallInt si(15);

add( si, 566 );

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

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

const matrix& add( const matrix &, int );

double add( double, double );

int main() {

   SmallInt si(15);

   add( si, 566 );

   // ...

}

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

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

namespace NS {

   class SmallInt { /* ... */ };

   class String { /* ... */ };

   String add( const String &, const String & );

}

int main() {

   // si имеет тип class SmallInt:

   // класс объявлен в пространстве имен NS

   NS::SmallInt si(15);

   add( si, 566 );  // NS::add() - функция-кандидат

   return 0;

}

Аргумент si имеет тип SmallInt, т.е. тип класса, объявленного в пространстве имен NS. Поэтому к множеству функций-кандидатов добавляется add(const String &, const String &), объявленная в этом пространстве имен;

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

namespace NS {

   class SmallInt {

      friend SmallInt add( SmallInt, int ) { /* ... */ }

   };

}

int main() {

   NS::SmallInt si(15);

   add( si, 566 );  // функция-друг add() - кандидат

   return 0;

}

Аргумент функции si имеет тип SmallInt. Функция-друг класса SmallInt add(SmallInt, int) – член пространства имен NS, хотя непосредственно в этом пространстве она не объявлена. При обычном поиске в NS функция-друг не будет найдена. Однако при вызове add() с аргументом типа класса SmallInt принимаются во внимание и добавляются к множеству кандидатов также друзья этого класса, объявленные в списке его членов.

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

Рассмотрим следующий пример:

namespace NS {

   class SmallInt {

      friend SmallInt add( SmallInt, int ) { /* ... */ }

   };

   class String { /* ... */ };

   String add( const String &, const String & );

}

const matrix& add( const matrix &, int );

double add( double, double );

int main() {

   // si имеет тип class SmallInt:

   // класс объявлен в пространстве имен NS

   NS::SmallInt si(15);

   add( si, 566 );  // вызывается функция-друг

   return 0;

}

Здесь кандидатами являются:

глобальные функции:

const matrix& add( const matrix &, int )

double add( double, double )

функция из пространства имен:

NS::add( const String &, const String & )

функция-друг:

NS::add( SmallInt, int )

При разрешении перегрузки выбирается функция-друг класса SmallInt NS::add( SmallInt, int ) как наилучшая из устоявших: оба фактических аргумента точно соответствуют заданным формальным параметрам.

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



namespace NS {

   class ZooAnimal {

      friend void display( const ZooAnimal& );

   };

}

// базовый класс Bear объявлен в пространстве имен NS

class Bear : public NS::ZooAnimal { };

int main() {

   Bear baloo;

   display( baloo );

   return 0;

}

Аргумент baloo функции display() имеет тип Bear. В его базовом классе ZooAnimal функция display() объявлена другом, поэтому она является членом пространства имен NS, хотя явно в нем не объявлена. При обычном просмотре NS она не была бы найдена. Однако поскольку аргумент display() имеет тип Bear, то объявленная в ZooAnimal функция-друг добавляется в множество кандидатов.

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

функций, видимых в точке вызова;

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

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

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

class ZooAnimal {

public:

   Time feeding_time( string );

   // ...

};

class Bear : public ZooAnimal {

public:

   // скрывает ZooAnimal::feeding_time( string )

   Time feeding_time( int );

   // ...

};

Bear Winnie;

// ошибка: ZooAnimal::feeding_time( string ) скрыта

Winnie.feeding_time( "Winnie" );

Функция-член feeding_time(int), объявленная в классе Bear, скрывает feeding_time(string), объявленную в ZooAnimal, базовом для Bear. Поскольку функция-член вызывается через объект Winnie типа Bear, то при поиске кандидатов для этого вызова просматривается только область видимости класса Bear, и единственным кандидатом будет feeding_time(int). Так как других кандидатов нет, вызов считается ошибочным.

Функции-кандидаты

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

func( args );

или функции-члена с помощью операторов доступа “точка” или “стрелка”:

object.memfunc( args );

pointer->memfunc( args );

В данном разделе мы изучим оба случая.

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

namespace NS {

   class ZooAnimal { /* ... */ };

   void display( const ZooAnimal& );

}

// базовый класс Bear объявлен в пространстве имен NS

class Bear : public NS::ZooAnimal { };

int main() {

   Bear baloo;

   display( baloo );

   return 0;

}

Аргумент baloo имеет тип класса Bear. Кандидатами для вызова display() будут не только функции, объявления которых видимы в точке ее вызова, но также и те, что объявлены в пространствах имен, в которых объявлены класс Bear и его базовый класс ZooAnimal. Поэтому в множество кандидатов добавляется функция display(const ZooAnimal&), объявленная в пространстве имен NS.

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

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

class Bear : public ZooAnimal {

public:

   // feeding_time( int ) перегружает экземпляр из класса ZooAnimal

   using ZooAnimal::feeding_time;

   Time feeding_time( int );

   // ...

};

Теперь обе функции feeding_time() находятся в области видимости класса Bear и, следовательно, войдут в множество кандидатов:

// правильно: вызывается ZooAnimal::feeding_time( string )

Winnie.feeding_time( "Winnie" );

В такой ситуации вызывается функция-член feeding_time( string ).

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

class Endangered {

public:

   ostream& print( ostream& );

   // ...

{;

class Bear : public( ZooAnimal ) {

public:

   void print( );

   using ZooAnimal::feeding_time;

   Time feeding_time( int );

   // ...

};

class Panda : public Bear, public Endangered {

public:

   // ...

};

int main()

{

   Panda yin_yang;

   // ошибка: неоднозначность: одна из

   //         Bear::print()

   //         Endangered::print( ostream& )

   yin_yang.print( cout );

   // правильно: вызывается Bear::feeding_time()

   yin_yang.feeding_time( 56 );

}

При поиске объявления функции-члена print() в области видимости класса Panda будут найдены как Bear::print(), так и Endangered::print(). Поскольку они не находятся в одном и том же базовом классе, то даже при разных списках параметров этих функций множество кандидатов оказывается пустым и вызов считается ошибочным. Для исправления ошибки в классе Panda следует определить собственную функцию print(). При поиске объявления функции-члена feeding_time() в области видимости Panda будут найдены ZooAnimal::feeding_time() и Bear::feeding_time() – они расположены в области видимости класса Bear. Так как эти объявления найдены в одном и том же базовом классе, множество кандидатов для данного вызова включает обе функции, а выбирается Bear::feeding_time().

Функции-кандидаты

Рассмотрим два вида вызовов функции-члена:

mc.mf( arg );

pmc->mf( arg );

где mc – выражение типа myClass, а pmc – выражение типа “указатель на тип myClass”. Множество кандидатов для обоих вызовов составлено из функций, найденных в области видимости класса myClass при поиске объявления mf().

Аналогично для вызова функции вида

myClass::mf( arg );

множество кандидатов также состоит из функций, найденных в области видимости класса myClass при поиске объявления mf(). Например:

class myClass {

public:

   void mf( double );

   void mf( char, char = '\n' );

   static void mf( int* );

   // ...

};

int main() {

   myClass mc;

   int iobj;

   mc.mf( iobj );

}

Кандидатами для вызова функции в main() являются все три функции-члена mf(), объявленные в myClass:

void mf( double );

void mf( char, char = '\n' );

static void mf( int* );

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

Функции-кандидаты для вызова функции в области видимости класса

Когда вызов функции вида

calc(t)

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

Рассмотрим пример:

namespace NS {

   struct myClass {

      void k( int );

      static void k( char* );

      void mf();

   };

   int k( double );

};

void h(char);

void NS::myClass::mf() {

   h('a');   // вызывается глобальная h( char )

   k(4);     // вызывается myClass::k( int )

}

Как отмечалось в разделе 13.11, квалификаторы NS::myClass:: просматриваются в обратном порядке: сначала поиск видимого объявления для имени, использованного в определении функции-члена mf(), ведется в классе myClass, а затем – в пространстве имен NS. Рассмотрим первый вызов:

h( 'a' );

При разрешении имени h() в определении функции-члена mf() сначала просматриваются функции-члены myClass. Поскольку функции-члена с таким именем в области видимости этого класса нет, то далее поиск идет в пространстве имен NS. Функции h()нет и там, поэтому мы переходим в глобальную область видимости. Результат – глобальная функция h(char), единственная функция-кандидат, видимая в точке вызова.

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

k( 4 );

Сначала поиск ведется в области видимости класса myClass. При этом найдены две функции-члена k(int) и k(char*). Поскольку множество кандидатов содержит лишь функции, объявленные в той области, где разрешение успешно завершилось, то пространство имен NS не просматривается и функция k(double) в данное множество не включается.

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

Функция main(): разбор параметров командной строки

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

prog -d -o of lie dataO

Фактические параметры являются аргументами функции main() и могут быть получены из массива C-строк с именем argv; мы покажем, как их использовать.

Во всех предыдущих примерах определение main() содержало пустой список:

int main() { ... }

Развернутая сигнатура main() позволяет получить доступ к параметрам, которые были заданы пользователем в командной строке:

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

argc содержит их количество, а argv – C-строки, представляющие собой отдельные значения (в командной строке они разделяются пробелами). Скажем, при запуске команды

prog -d -o ofile data0

argc получает значение 5, а argv включает следующие строки:

argv[ 0 ] = "prog";

argv[ 1 ] = "-d";

argv[ 2 ] = "-o";

argv[ 3 ] = "ofile";

argv[ 4 ] = "dataO";

В argv[0] всегда входит имя команды (программы). Элементы с индексами от 1 до argc-1 служат параметрами.

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

prog [-d] [-h] [-v]

     [-o output_file] [-l limit_value]

     file_name

     [ file_name [file_name [ ... ]]]

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

prog chap1.doc

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

prog -l 1024 -o chap1-2.out chapl.doc chap2.doc

prog d chap3.doc

prog -l 512 -d chap4.doc

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

1.      По очереди извлечь каждый параметр из argv. Мы используем для этого цикл for с начальным индексом 1 (пропуская, таким образом, имя программы):

for ( int ix = 1; ix < argc; ++ix ) {

    char *pchar = argv[ ix ];

    // ...

}

2.      Определить тип параметра. Если строка начинается с дефиса (-), это одна из опций { h, d, v, l, o}. В противном случае это может быть либо значение, ассоциированное с опцией (максимальный размер для -l, имя выходного файла для -o), либо имя входного файла. Чтобы определить, начинается ли строка с дефиса, используем инструкцию switch:

switch ( pchar[ 0 ] ) {

   case '-': {

     //  -h, -d, -v, -l, -o

   }

   default: {

     // обработаем максимальный размер для опции -1

     //            имя выходного файла для       -o

     //            имена входных файлов ...

   }

}

Реализуем обработку двух случаев пункта 2.

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

case '-': {

  switch( pchar[ 1 ] )

  {

    case 'd':

      // обработка опции debug

      break;

    case 'v':

      // обработка опции version

      break;

    case 'h':

      // обработка опции help

      break;

    case 'o':

      // приготовимся обработать выходной файл

      break;

    case 'l':

      // приготовимся обработать макс.размер

      break;

    default:

      // неопознанная опция:

      // сообщить об ошибке и завершить выполнение

  }

}

Опция -d задает необходимость отладки. Ее обработка заключается в присваивании переменной с объявлением

bool debug_on = false;

значения true:

case 'd':

  debug_on = true;

break;

В нашу программу может входить код следующего вида:

if ( debug_on )

    display_state_elements( obj );

Опция -v выводит номер версии программы и завершает исполнение:

case 'v':

  cout << program_name << "::"

       << program_version << endl;

  return 0;

Опция -h запрашивает информацию о синтаксисе запуска и завершает исполнение. Вывод сообщения и выход из программы выполняется функцией usage():

case 'h':

  // break не нужен: usage() вызывает exit()

  usage();

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

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



// если ofi1e_on==true,

// следующий параметр - имя выходного файла

bool ofi1e_on = false;

// если ofi1e_on==true,

// следующий параметр - максимальный размер

bool limit_on = false;

Вот обработка опций -l и -o в нашей инструкции switch:

case 'l':

  limit_on = true;

  break;

case 'o':

  ofile_on = true;

  break;

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

// обработаем максимальный размер для опции -1

//            имя выходного файла для       -o

//            имена входных файлов ...

default: {

   // ofile_on включена, если -o встречалась

   if ( ofile_on ) {

     // обработаем имя выходного файла

     // выключим ofile_on

   }

   else if ( limit_on ) { // если -l встречалась

     // обработаем максимальный размер

     // выключим limit_on

   } else {

     // обработаем имя входного файла

   }

}

Если аргумент является именем выходного файла, сохраним это имя и выключим ofile_on:

if ( ofile_on ) {

  ofile_on = false;

  ofile = pchar;

}

Если аргумент задает максимальный размер, мы должны преобразовать строку встроенного типа в представляемое ею число. Сделаем это с помощью стандартной функции atoi(), которая принимает строку в качестве аргумента и возвращает int (также существует функция atof(), возвращающая double). Для использования atoi() включим заголовочный файл ctype.h. Нужно проверить, что значение максимального размера неотрицательно и выключить limit_on:

// int limit;

else

if ( limit_on ) {

  limit_on = false;

  limit = atoi( pchar );

  if ( limit < 0 ) {

    cerr << program_name << "::"

         << program_version << " : error: "

         << "negative value for limit.\n\n";

    usage( -2 );

  }

}

Если обе переменных состояния равны false, у нас есть имя входного файла. Сохраним его в векторе строк:

else

  file_names.push_back( string( pchar ));

При обработке параметров командной строки важен способ реакции на неверные опции. Мы решили, что задание отрицательной величины в качестве максимального размера будет фатальной ошибкой. Это приемлемо или нет в зависимости от ситуации. Также можно распознать эту ситуацию как ошибочную, выдать предупреждение и использовать ноль или какое-либо другое значение по умолчанию.



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

prog - d dataOl

prog -oout_file dataOl

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

Вот полный текст нашей программы. (Мы добавили инструкции печати для трассировки выполнения.)

#include <iostream>

#include <string>

#include <vector>

#include <ctype.h>

const char *const program_name = "comline";

const char *const program_version = "version 0.01 (08/07/97)";

inline void usage( int exit_value = 0 )

{

  // печатает отформатированное сообщение о порядке вызова

  // и завершает программу с кодом exit_value ...

  cerr << "порядок вызова:\n"

       << program_name << " "

       << "[-d] [-h] [-v] \n\t"

       << "[-o output_file] [-l limit] \n\t"

       << "file_name\n\t[file_name [file_name [ ... ]]]\n\n"

       << "где [] указывает на необязательность опции:\n\n\t"

       << "-h: справка.\n\t\t"

       << "печать этого сообщения и выход\n\n\t"

       << "-v: версия.\n\t\t"

       << "печать информации о версии программы и выход\n\n\t"

       << "-d: отладка.\n\t\t включает отладочную печать\n\n\t"

       << "-l limit\n\t\t"

       << "limit должен быть неотрицательным целым числом\n\n\t"

       << "-o ofile\n\t\t"

       << "файл, в который выводится результат\n\t\t"

       << "по умолчанию результат записывается на стандартный вывод\n\n"

       << "file_name\n\t\t"

       << "имя подлежащего обработке файла\n\t\t"

       << "должно быть задано хотя бы одно имя --\n\t\t"



       << "но максимальное число не ограничено\n\n"

       << "примеры:\n\t\t"

       << "$command chapter7.doc\n\t\t"

       << "$command -d -l 1024 -o test_7_8 "

       << "chapter7.doc chapter8.doc\n\n";

  exit( exit_value );

}

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

{

  bool debug_on = false;

  bool ofile_on = false;

  bool limit_on = false;

  int limit = -1;

  string ofile;

  vector<string> file_names;

  cout << "демонстрация обработки параметров в командной строке:\n"

       << "argc: " << argc << endl;

  for ( int ix = 1; ix < argc; ++ix )

  {

    cout << "argv[ " << ix << " ]: "

         << argv[ ix ] << endl;

    char *pchar = argv[ ix ];

    switch ( pchar[ 0 ] )

    {

      case '-':

      {

        cout << "встретился \'-\'\n";

        switch( pchar[ 1 ] )

        {

          case 'd':

            cout << "встретилась -d: "

                 << "отладочная печать включена\n";

            debug_on = true;

            break;

          case 'v':

            cout << "встретилась -v: "

                 << "выводится информация о версии\n";

            cout << program_name

                 << " ::  "

                 << program_version

                 << endl;

            return 0;

          case 'h':

            cout << "встретилась -h: "

                 << "справка\n";

            // break не нужен: usage() завершает программу

            usage();

          case 'o':

            cout << "встретилась -o: выходной файл\n";

            ofile_on = true;

            break;

          case 'l':

            cout << "встретилась -l: "



                 << "ограничение ресурса\n";

            limit_on = true;

            break;

          default:

            cerr << program_name

                 << " : ошибка : "

                 << "неопознанная опция: - "

                 << pchar << "\n\n";

            // break не нужен: usage() завершает программу

            usage( -1 );

        }

        break;

      }

      default: // либо имя файла

        cout << "default: параметр без дефиса: "

             << pchar << endl;

        if ( ofile_on ) {

          ofile_on = false;

          ofile = pchar;

        }

        else

        if ( limit_on ) {

          limit_on = false;

          limit = atoi( pchar );

          if ( limit < 0 ) {

            cerr << program_name

                 << " : ошибка : "

                 << "отрицательное значение limit.\n\n";

            usage( -2 );

          }

        }

        else file_names.push_back( string( pchar ));

        break;

    }

  }

  if ( file_names.empty() ) {

    cerr << program_name

         << " : ошибка : "

         << " не задан ни один входной файл.\n\n";

    usage( -3 );

  }

  if ( limit != -1 )

    cout << "Заданное пользователем значение limit: "

         << limit << endl;

  if ( ! ofile.empty() )

    cout << "Заданный пользователем выходной файл: "

         << ofile << endl;

  cout << (file_names.size() == 1 ? "Файл, " : "Файлы, ")

       << "подлежащий(е) обработке:\n";

  for ( int inx = 0; inx < file_names.size(); ++inx )

    cout << "\t" << file_names[ inx ] << endl;

}

a.out -d -l 1024 -o test_7_8 chapter7.doc    chapters.doc

Вот трассировка обработки параметров командной строки:

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

argc: 8

argv[ 1 ]: -d

встретился '-'

встретилась -d: отладочная печать включена

argv[ 2 ]: -l

встретился '-'

встретилась -l: ограничение ресурса

argv[ 3 ]: 1024

default: параметр без дефиса: 1024

argv[ 4 ]: -o

встретился '-'

встретилась -o: выходной файл

argv[ 5 ]: test_7_8

default: параметр без дефиса: test_7_8

argv[ 6 ]: chapter7.doc

default: параметр без дефиса: chapter7.doc

argv[ 7 ]: chapter8.doc

default: параметр без дефиса: chapter8.doc

Заданное пользователем значение limit: 1024

Заданный пользователем выходной файл: test_7_8

Файлы, подлежащий(е) обработке:

        chapter7.doc

        chapter8.doc

Глобальные объекты и функции

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

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

Готовим сцену

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

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

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

Добавление объектов к сцене, их перемещение, игра с источниками освещения и геометрией– работа компьютерного художника. Наша задача – предоставить интерактивную поддержку для манипуляций с графом сцены на экране. Предположим, что в текущей версии своего инструмента мы решили воспользоваться каркасом приложений Open Inventor для C++ (см. [WERNECKE94]), но с помощью подтипизации расширили его, создав собственные абстракции нужных нам классов. Например, Open Inventor располагает тремя встроенными источниками освещения, производными от абстрактного базового класса SoLight:

class SoSpotLight : public SoLight { ... }

class SoPointLight : public SoLight { ... }

class SoDirectionalLight : public SoLight { ... }

Префикс So служит для того, чтобы дать уникальные имена сущностям, которые в области компьютерной графики весьма распространены (данный каркас приложений проектировался еще до появления пространств имен). Точечный источник (point light) – это источник света, излучающий, как солнце, во всех направлениях. Направленный источник (directional light) – источник света, излучающий в одном направлении. Прожектор (spotlight) – источник, испускающий узконаправленный конический пучок, как обычный театральный прожектор.

По умолчанию Open Inventor осуществляет рендеринг графа сцены на экране с помощью библиотеки OpenGL (см. [NEIDER93]). Для интерактивного отображения этого достаточно, но почти все изображения, сгенерированные для киноиндустрии, сделаны с помощью средства RenderMan (см. [UPSTILL90]). Чтобы добавить поддержку такого алгоритма рендеринга мы, в частности, должны реализовать собственные специальные подтипы источников освещения:

class RiSpotLight : public SoSpotLight { ... }

class RiPointLight : public SoPointLight { ... }

class RiDirectionalLight : public SoDirectionalLight { ... }

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

В RenderMan направленный источник и прожектор поддерживают отбрасывание тени (поэтому мы называем их источниками освещения, дающими тень, – SCLS), а точечный – нет. Общий алгоритм требует, чтобы мы обошли все источники освещения на сцене и составили карту теней для каждого включенного SCLS. Проблема в том, что источники освещения хранятся в графе сцены как полиморфные объекты класса SoLight. Хотя мы можем инкапсулировать общие данные и необходимые операции в класс SCLS, непонятно, как включить его в существующую иерархию классов Open Inventor.

В поддереве с корнем SoLight в иерархии Open Inventor нет такого класса, из которого можно было бы произвести с помощью одиночного наследования класс SCLS так, чтобы в дальнейшем уже от него произвести SdRiSpotLight и SdRiDirectionalLight. Если не пользоваться множественным наследованием, лучшее, что можно сделать, – это сравнить член класса SCLS с каждым возможным типом SCLS-источника и вызвать соответствующую операцию:

SoLight *plight = next_scene_light();

if ( RiDirectionalLight *pdilite =

     dynamic_cast<RiDirectionalLight*>( plight ))

         pdilite->scls.cast_shadow_map();



else

if ( RiSpotLight *pslite =

     dynamic_cast<RiSpotLight*>( plight ))

         pslite->scls.cast_shadow_map();

// и так далее

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

Пользуясь множественным наследованием, мы можем инкапсулировать подтипы SCLS, защитив наш код от изменений при добавлении или удалении источника освещения (см. рис. 18.1).

                        SoNode                                                                                         SCLS

                        SoLight

     SoPointLight                   SoSpotLight                    SoDirectionalLight

       RPointLight                      RSpotLight                    RDirectionalLight

Рис. 18.1. Множественное наследование источников освещения

class RiDirectionalLight :

      public SoDirectionalLight, public SCLS { ... };

class RiSpotLight :

      public SoSpotLight, public SCLS { ... };

// ...

SoLight *plight = next_scene_light();

if ( SCLS *pscls = dynamic_cast<SCLS*>(plight))

   pscls->cast_shadow_map();

Это решение несовершенно. Если бы у нас был доступ к исходным текстам Open Inventor, то можно было бы избежать множественного наследования, добавив к SoLight член-указатель на SCLS и поддержку операции cast_shadow_map():

class SoLight : public SoNode {

public:

   void cast_shadow_map()

        { if ( _scls ) _scls->cast_shadow_map(); }

   // ...

protected:

   SCLS *_scls;

};

// ...

SdSoLight *plight = next_scene_light();

plight-> cast_shadow_map();

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

информация о форматировании (представляется ли целое число в десятичной, восьмеричной или шестнадцатеричной системе счисления, число с плавающей точкой – в нотации с фиксированной точкой или в научной нотации и т.д.);



информация о состоянии (находится ли потоковый объект в нормальном или ошибочном состоянии и т.д.);

информация о параметрах локализации (отображается ли в начале даты день или месяц и т.д.);

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

Эти общие атрибуты вынесены в абстрактный базовый класс ios, для которого istream и ostream являются производными.

Класс iostream – наш второй пример множественного наследования. Он предоставляет поддержку для чтения и записи в один и тот же файл; его предками являются классы istream и ostream. К сожалению, по умолчанию он также унаследует два различных экземпляра базового класса ios, а нам это не нужно.

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

Ios

istream                               ostream

ifstream                               iostream                               ofstream

fstream

Рис. 18.2. Иерархия виртуального наследования iostream (упрощенная)

Еще один реальный пример виртуального и множественного наследования дают распределенные объектные вычисления. Подробное рассмотрение этой темы см. в серии статей Дугласа Шмидта (Douglas Schmidt) и Стива Виноски (Steve Vinoski) в [LIPPMAN96b].

В данной главе мы рассмотрим использование и поведение механизмов виртуального и множественного наследования. В другой нашей книге, “Inside the C++ Object Model”, описаны более сложные вопросы производительности и дизайна этого аспекта языка.

Для последующего обсуждения мы выбрали иерархию животных в зоопарке. Наши животные существуют на разных уровнях абстракции. Есть, конечно, особи, имеющие свои имена: Линь-Линь, Маугли или Балу. Каждое животное принадлежит к какому-то виду; скажем, Линь-Линь – это гигантская панда. Виды в свою очередь входят в семейства. Так, гигантская панда – член семейства медведей, хотя, как мы увидим в разделе 18.5, по этому поводу в зоологии долго велись бурные дискуссии. Каждое семейство – член животного мира, в нашем случае ограниченного территорией зоопарка.

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

Помимо классов, описывающих животных, есть и вспомогательные классы, инкапсулирующие различные абстракции иного рода, например “животные, находящиеся под угрозой вымирания”. Наша реализация класса Panda множественно наследует от Bear (медведь) и Endangered (вымирающие).

Идентификация членов иерархии

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

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

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

На следующем шаге проектирования иерархии классов Query следует ответить на такие вопросы:

(a)               Какие операции следует предоставить в открытом интерфейсе иерархии классов Query?

(b)               Какие из них следует объявить виртуальными?

(c)                Какие дополнительные операции могут потребоваться производным классам?

(d)               Какие данные-члены следует объявить в нашем абстрактном базовом классе Query?

(e)                Какие данные-члены могут потребоваться производным классам?

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

Идентификация типов во время выполнения

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

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

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

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

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

Иерархия классов исключений в стандартной библиотеке C++

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

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

namespace std {

   class exception

   public:

      exception() throw();

      exception( const exception & ) throw();

      exception& operator=( const exception & ) throw();

      virtual ~exception() throw();

      virtual const char* what() const throw();

   };

}

Как и всякий другой класс из стандартной библиотеки C++, exception помещен в пространство имен std, чтобы не засорять глобальное пространство имен программы.

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

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

Отметим, что все функции в определении класса exception имеют пустую спецификацию throw(), т.е. не возбуждают никаких исключений. Программа может манипулировать объектами-исключениями (к примеру, внутри catch-обработчиков типа exception), не опасаясь, что функции создания, копирования и уничтожения этих объектов возбудят исключения.

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

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

namespace std {

   class logic_error : public exception {  // логическая ошибка

   public:

      explicit logic_error( const string &what_arg );

   };

   class invalid_argument : public logic_error { // неверный аргумент

   public:

      explicit invalid_argument( const string &what_arg );

   };

   class out_of_range : public logic_error { // вне диапазона

   public:

      explicit out_of_range( const string &what_arg );

   };

   class length_error : public logic_error { // неверная длина

   public:

      explicit length_error( const string &what_arg );

   };

   class domain_error : public logic_error { // вне допустимой области

   public:

      explicit domain_error( const string &what_arg );

   };

}

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

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

namespace std {

   class runtime_error : public exception {  // ошибка времени выполнения

   public:

      explicit runtime_error( const string &what_arg );



   };

   class range_error : public runtime_error { // ошибка диапазона

   public:

      explicit range_error( const string &what_arg );

   };

   class overflow_error : public runtime_error { // переполнение

   public:

      explicit overflow_error( const string &what_arg );

   };

   class underflow_error : public runtime_error { // потеря значимости

   public:

      explicit underflow_error( const string &what_arg );

   };

}

Функция может возбудить исключение range_error, чтобы сообщить об ошибке во внутренних вычислениях. Исключение overflow_error говорит об ошибке арифметического переполнения, а underflow_error – о потере значимости.

Класс exception является базовым и для класса исключения bad_alloc, которое возбуждает оператор new(), когда ему не удается выделить запрошенный объем памяти (см. раздел 8.4), и для класса исключения bad_cast, возбуждаемого в ситуации, когда ссылочный вариант оператора dynamic_cast не может быть выполнен (см. раздел 19.1).

Переопределим оператор operator[] в шаблоне Array из раздела 16.12 так, чтобы он возбуждал исключение типа range_error, если индекс массива Array выходит за границы:

#include <stdexcept>

#include <string>

template <class elemType>

class Array {

public:

   // ...

   elemType& operator[]( int ix ) const

   {

      if ( ix < 0 || ix >= _size )

      {

         string eObj =

         "ошибка: вне диапазона в Array<elemType>::operator[]()";

         throw out_of_range( eObj );

      }

      return _ia[ix];

   }

   // ...

private:

   int _size;

   elemType *_ia;

};

Для использования предопределенных классов исключений в программу необходимо включить заголовочный файл <stdexcept>. Описание возбужденного исключения содержится в объекте eObj типа string. Эту информацию можно извлечь в обработчике с помощью функции-члена what():

int main()

{

   try {

      // функция main() такая же, как в разделе 16.2



   }

   catch ( const out_of_range &excep ) {

      // печатается:

      // ошибка: вне диапазона в Array<elemType>::operator[]()

      cerr << excep.what() << "\n";

      return -1;

   }

}

В данной реализации выход индекса за пределы массива в функции try_array() приводит к тому, что оператор взятия индекса operator[]() класса Array возбуждает исключение типа out_of_range, которое перехватывается в main().

Упражнение 19.5

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

#include <stdexcept>

(a) void operate() throw( logic_error );

(b) int mathErr( int ) throw( underflow_error, overflow_error );

(c) char manip( string ) throw( );

Упражнение 19.6

Объясните, как механизм обработки исключений в C++ поддерживает технику программирования “захват ресурса – это инициализация; освобождение ресурса – это уничтожение”.

Упражнение 19.7

Исправьте ошибку в списке catch-обработчиков для данного try-блока:

#include <stdexcept>

int main() {

   try {

      // использование функций из стандартной библиотеки

   }

   catch( exception ) {

   }

   catch( runtime_error &re ) {

   }

   catch( overflow_error eobj ) {

   }

}

Упражнение 19.8

Дана программа на C++:

int main() {

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

}

Модифицируйте main() так, чтобы она перехватывала все исключения, возбуждаемые функциями стандартной библиотеки. Обработчики должны печатать сообщение об ошибке, ассоциированное с исключением, а затем вызывать функцию abort() (она определена в заголовочном файле <cstdlib>) для завершения main().

Имена перегруженных операторов

Перегружать можно только предопределенные операторы языка C++ (см. табл. 15.1).

Таблица 15.1. Перегружаемые операторы

+

-

*

/

%

^

&

|

~

!

,

=

<

>

<=

>=

++

--

<<

>>

==

!=

&&

||

+=

-=

/=

%=

^=

&=

|=

*=

<<=

>>=

[]

()

->

->*

new

new[]

delete

delete[]

Проектировщик класса не вправе объявить перегруженным оператор с другим именем. Так, при попытке объявить оператор ** для возведения в степень компилятор выдаст сообщение об ошибке.

Следующие четыре оператора языка C++ не могут быть перегружены:

// неперегружаемые операторы

:: .* . ?:

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

// ошибка: нельзя переопределить встроенный оператор сложения int

int operator+( int, int );

Нельзя также определять дополнительные операторы для встроенных типов данных, например добавить к множеству встроенных операций operator+ для сложения двух массивов.

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

Предопределенные приоритеты операторов (см. раздел 4.13) изменить нельзя. Независимо от типа класса и реализации оператора в инструкции

x == y + z;

всегда сначала выполняется operator+, а затем operator==; однако помощью скобок порядок можно изменить.

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

// некорректно: ! - это унарный оператор

bool operator!( const String &s1, const String &s2 )

{

   return ( strcmp( s1.c_str(), s2.c_str() ) != 0 );

}

Для встроенных типов четыре предопределенных оператора ("+", "-", "*" и "&") используются либо как унарные, либо как бинарные. В любом из этих качеств они могут быть перегружены.

Для всех перегруженных операторов, за исключением operator(), недопустимы аргументы по умолчанию.

Имя переменной

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

Некоторые слова являются ключевыми в С++ и не могут быть использованы в качестве идентификаторов; в таблице 3.1 приведен их полный список.

Таблица 3.1. Ключевые слова C++

asm		auto		bool		break		case
catch		char		class		const		const_cast
continue		default		delete		do		double
dynamic_cast		else		enum		explicit		export
extern		false		float		for		friend
goto		if		inline		int		long
mutable		namespace		new		operator		private
protected		public		register		reinterpret_cast		return
short		signed		sizeof		static		static_cast
struct		switch		template		this		throw
true		try		typedef		typeid		typename
union		unsigned		using		virtual		void
volatile		wchar_t		while

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

имя переменной обычно пишется строчными буквами, например index (для сравнения: Index – это имя типа, а INDEX – константа, определенная с помощью директивы препроцессора #define);

идентификатор должен нести какой-либо смысл, поясняя назначение объекта в программе, например: birth_date или salary;

если такое имя состоит из нескольких слов, как, например, birth_date, то принято либо разделять слова символом подчеркивания (birth_date), либо писать каждое следующее слово с большой буквы (birthDate). Замечено, что программисты, привыкшие к ОбъектноОриентированномуПодходу предпочитают выделять слова заглавными буквами, в то время как те_кто_много_писал_на_С используют символ подчеркивания. Какой из двух способов лучше – вопрос вкуса.

Инициализация члена, являющегося объектом класса

Что произойдет, если в объявлении _name заменить C-строку на тип класса string? Как это повлияет на почленную инициализацию по умолчанию? Как надо будет изменить явный копирующий конструктор? Мы ответим на эти вопросы в данном подразделе.

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

newAcct._name = oldAcct._name;

Члены, являющиеся объектами классов, обрабатываются по-другому. В инструкции

Account newAcct( oldAcct );

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

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

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

inline Account::

Account( const Account &rhs )

{

   _acct_nmbr = rhs._acct_nmbr;

   _balance = rhs._balance;

   // Псевдокод на C++

   // иллюстрирует вызов копирующего конструктора

   // для члена, являющегося объектом класса

   _name.string::string( rhs._name );

}

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

// не совсем правильно...

inline Account::

Account( const Account &rhs )

{

   _name = rhs._name;

   _balance = rhs._balance;

   _acct_nmbr = get_unique_acct_nmbr();

}

Эта реализация ошибочна, поскольку в ней не различаются инициализация и присваивание. В результате вместо вызова копирующего конструктора string мы вызываем конструктор string по умолчанию на фазе неявной инициализации и копирующий оператор присваивания string – в теле конструктора. Исправить это несложно:

inline Account::

Account( const Account &rhs )

       : _name( rhs._name )

{

   _balance = rhs._balance;

   _acct_nmbr = get_unique_acct_nmbr();

}

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

Упражнение 14.13

Для какого определения класса скорее всего понадобится копирующий конструктор?

1.      Представление Point3w, содержащее четыре числа с плавающей точкой.

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

3.      Класс payroll (платежная ведомость), где каждому объекту приписывается уникальный идентификатор.

4.      Класс word (слово), содержащий объект класса string и вектор, в котором хранятся пары (номер строки, смещение в строке).

Упражнение 14.14

Реализуйте для каждого из данных классов копирующий конструктор, конструктор по умолчанию и деструктор.



 (a) class BinStrTreeNode {

    public:

       // ...

    private:

       string _value;

       int    _count;

       BinStrTreeNode *_leftchild;

       BinStrTreeNode *_rightchild;

    };

(b) class BinStrTree {

    public:

       // ...

    private:

       BinStrTreeNode *_root;

    };

(c) class iMatrix {

    public:

       // ...

    private:

       int  _rows;

       int  _cols;

       int *_matrix;

    };

(d) class theBigMix {

    public:

       // ...

    private:

       BinStrTree    _bst;

       iMatrix       _im;

       string        _name;

       vectorMfloat> *_pvec;

    };

Упражнение 14.15

Нужен ли копирующий конструктор для того класса, который вы выбрали в упражнении 14.3 из раздела 14.2? Если нет, объясните почему. Если да, реализуйте его.

Упражнение 14.16

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

Point global;

Point foo_bar( Point arg )

{

   Point local = arg;

   Point *heap = new Point( global );

   *heap = local;

   Point pa[ 4 ] = { local, *heap };

   return *heap;

}

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

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

lexicoCompare;

получается указатель типа

int (*)( const string &, const string & );

Применение оператора взятия адреса к имени функции также дает указатель того же типа, например lexicoCompare и &lexicoCompare. Указатель на функцию инициализируется следующим образом:

int (*pfi)( const string &, const string & ) = lexicoCompare;

int (*pfi2)( const string &, const string & ) = &lexicoCompare;

Ему можно присвоить значение:

pfi = lexicoCompare;

pfi2 = pfi;

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

int calc( int, int );

int (*pfi2s)( const string &, const string & ) = 0;

int (*pfi2i)( int, int ) = 0;

int main() {

    pfi2i = calc;  // правильно

    pri2s = calc;  // ошибка: несовпадение типов

    pfi2s = pfi2i; // ошибка: несовпадение типов

    return 0;

}

Такой указатель можно инициализировать нулем или присвоить ему нулевое значение, в этом случае он не адресует функцию.

---

---