Скомпилировать и запустить программу вы можете например так:

$ CC main.c f.c -o silly $ silly дурацкий, но полный $

Давайте посмотрим, как мы могли бы определить тип потока вывода ostream. Чтобы упростить задачу, предположим, что для буферизации определен тип streambuf. Тип streambuf на самом деле определен в «stream.h», где также находится и настоящее определение ostream.

Пожалуйста, не испытывайте примеры, определяющие ostream в этом и последующих разделах. Пока вы не сможете полностью избежать использования «stream.h», компилятор будет возражать против переопределений.

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

class ostream (* streambuf* buf; int state; public: void put(char*); void put(long); void put(double); *)

Описания после метки public: задают интерфейс: пользователь может обращаться только к трем функциям put(). Описания перед меткой public задают представление объекта класса ostream. Имена buf и state могут использоваться только функциями put(), описанными в открытой части.

class определяет тип, а не объект данных, поэтому чтобы использовать ostream, мы должны один такой объект описать (так же, как мы описываем переменные типа int):

ostream my_out;

Считая, что my_out был соответствующим образом проинициализирован (как, объясняется в #1.10), его можно использовать например так:

my_out.put(«Hello, world\n»);

С помощью операции точка выбирается член класса для данного объекта этого класса. Здесь для объекта my_out вызывается член функция put().

Функция может определяться так:

void ostream::put(char* p) (* while (*p) buf.sputc(*p++); *)

где sputc() – функция, которая помещает символ в streambuf. Префикс ostream необходим, чтобы отличить put() ostream'а от других функций с именем put().

Для обращения к функции члену должен быть указан объект класса. В функции члене можно ссылаться на этот объект неявно, как это делалось выше в ostream::put(): в каждом вызове buf относится к члену buf объекта, для которого функция вызвана. Можно также ссылаться на этот объект явно посредством указателя с именем this. В функции члене класса X this неявно описан как X* (указатель на X) и инициализирован указателем на тот объект, для которого эта функция вызвана. Определение ostream::put() можно также записать в виде:

void ostream::put(char* p) (* while (*p) this-»buf.sputc(*p++); *) Операция -» применяется для выбора члена объекта, заданного указателем.

Настоящий класс ostream определяет операцию ««, чтобы сделать удобным вывод нескольких объектов одним оператором. Давайте посмотрим, как это сделано.

Чтобы определить @, где @ – некоторая операция языка С++, для каждого определяемого пользователем типа вы определяете функцию с именем operator@, которая получает параметры соответствующего типа. Например:

class ostream (* //... ostream operator««(char*); *);

ostream ostream::operator««(char* p) (* while (*p) buf.sputc(*p++); return *this; *)

определяет операцию «« как член класса ostream, поэтому s««p интерпретируется как s.operator««(p), когда s является ostream и p – указатель на символ. Операция «« бинарна, а функция operator««(char*) на первый взгляд имеет только один параметр. Однако, помимо этого она имеет свой стандартный параметр this.

То, что в качестве возвращаемого значения возвращается ostream, позволяет применять «« к результату операции вывода. Например, s««p««q интерпретируется как (s.operator««(p)).operator««(q). Так задаются операции вывода для встроенных типов.

С помощью множества операций, заданных как открытые члены класса ostream, вы можете теперь определить «« для такого определяемого типа, как complex, не изменяя описание класса ostream:

ostream operator««(ostream s, complex z) // у complex две части: действительная real и мнимая imag // печатает complex как (real,imag) (* return s «« "(" «« z.real «« "," «« z.imag «« ")'; *)

Поскольку operator««(ostream,complex) не является функцией членом, для бинарности необходимо два явных параметра. Вывод значений будет производиться в правильном порядке, потому что ««, как и большинство операций С++, группирует слева направо, то есть f««b««c означает (a««b)««c. При интерпретации операций компилятору известна разница между функциями членами и функциями не членами. Например, если z – комплексная переменная, то s««z будет расширяться с помощью вызова стандартной функции (не члена) operator««(s,z).

К сожалению, последняя версия ostream содержит серьезную ошибку и к тому же очень неэффективна. Сложность состоит в том, что ostream копируется дважды при каждом использовании ««: один раз как параметр и один раз как возвращаемое значение. Это оставляет state неизмененным после каждого вызова. Необходима возможность передачи указателя на ostream вместо передачи самого ostream.

Это можно сделать с помощью ссылок. Ссылка действует как имя для объекта. T amp; означает ссылку на T. Ссылка должна быть инициализирована, и она становится другим именем того объекта, которым она инициализирована. Например:

ostream amp; s1 = my_out; ostream amp; s2 = cout;

Теперь можно использовать ссылку s1 и my_out одинаково, и они будут иметь одинаковые значения. Например, присваивание

s1 = s2;

копирует объект, на который ссылается s2 (то есть, cout), в объект, на который ссылается s1 (то есть, my_out). Члены берутся с помощью операции точка

s1.put(«не надо использовать -»»);

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

amp;s1 == amp;my_out

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

ostream amp; operator««(ostream amp; s, complex z) (* return s «« "(" «« z.real «« "," «« z.imag «« ")"; *)

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

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

class istream (* //... int state; public: istream amp; operator»»(char amp;); istream amp; operator»»(char*); istream amp; operator»»(int amp;); istream amp; operator»»(long amp;); //... *);

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

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