Чтение онлайн

Описание overload pow;

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

Если функция не возвращает значения, то ее следует описать как void:

void swap(int* p, int* q) // поменять местами (* int t = *p; *p = *q; *q = t; *)

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

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

extern double sqrt(double); extern instream cin;

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

#include «math.h» //... x = sqrt(4);

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

В команде включения include имя файла, заключенное в угловые скобки, например «math.h», относится к файлу с этим именем в стандартном каталоге (часто это /usr/include/CC), на файлы, находящиеся в каких-либо других местах ссылаются с помощью имен, заключенных в двойные кавычки. Например:

#include «math1.h» #include «/usr/bs/math2.h»

включит math1.h из текущего пользовательского каталога, а math2.h из каталога /usr/bs.

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

// header.h

extern char* prog_name; extern void f;

В файле main.c находится главная программа:

// main.c

#include «header.h» char* prog_name = «дурацкий, но полный»; main (* f; *)

а файл f.c печатает строку:

// f.c

#include «stream.h» #include «header.h» void f (* cout «„ prog_name «« «\n“; *)

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

$ 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@, которая получает параметры соответствующего типа. Например: