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

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

extern double sqrt(double); extern instream cin;

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

#include //... x = sqrt(4);

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

В команде включения include имя файла, заключенное в угловые скобки, например, относится к файлу с этим именем в стандартном каталоге (часто это /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 #include "header.h" void f() { cout << prog_name << "\n"; }

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

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

Классы

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

Определение типа, определяемого пользователем (который в C++ называется 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++); }

Операция -> применяется для выбора члена объекта, заданного указателем.