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

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

В файле fileLcpp

Foo foo;

Foo* f = &foo;

В файле fi1e2.cpp

extern Foo* f;

Foo f1(*f); Используется конструктор копий

Если бы все это находилось в одном исходном файле, ситуация была бы нормальной. Со строкой Fоо* f = &foo; проблем не возникает, поскольку глобальные объекты одного исходного файла заведомо (хе-хе) инициализируются в порядке их определения. Другими словами, когда программа доберется до этой строки, объект foo уже будет сконструирован. Тем не менее, никто не гарантирует, что глобальные объекты в файле file1.cpp будут инициализированы раньше глобальных объектов в файле file2.срр. Если file2.cpp будет обрабатываться первым, f оказывается равным 0 (NULL на большинстве компьютеров), и при попытке получить по нему объект ваша программа героически умрет.

Лучший выход - сделать так, чтобы программа не рассчитывала на конкретный порядок инициализации файлов .срр. Для этого используется стандартный прием - в заголовочном файле .h определяется глобальный объект со статической переменной, содержащей количество инициализированных файлов .срр. При переходе от 0 к 1 вызывается функция, которая инициализирует все глобальные объекты библиотечного файла .срр. При переходе от 1 к 0 все объекты этого файла уничтожаются.

В файле Library.h class Library { private:

static int count;

static void OpenLibrary();

static void CloseLibrary(); public:

LibraryC);

~Library();

static Library LibraryDummy; inline Library::Library()

if (count++ == 0) OpenLi brary();

inline Library::~Library()

if (--count == 0)

CloseLibrary();

В Library.cpp

int Library::count = 0; Делается перед выполнением вычислений

int aGlobal ;

Foo* aGlobalFoo;

void Library::OpenLibrary()

aGlobal = 17; aGlobalFoo = new Foo;

void Library::CloseLibrary()

aGlobal = 0; delete aGlobalFoo; aGlobalFoo = NULL;

К этому нужно привыкнуть. А происходит следующее: файл .h компилируется со множеством других файлов .срр, один из которых - Library.cpp. Порядок инициализации глобальных объектов, встречающихся в этих файлах, предсказать невозможно. Тем не менее, каждый из них будет иметь свою статическую копию LibraryDummy. При каждой инициализации файла .срр, в который включен файл Library.h, конструктор LibraryDummy увеличивает счетчик. При выходе из main() или при вызове exit() файлы .срр уничтожают глобальные объекты и уменьшают счетчик в деструкторе LibraryDummy. Конструктор и деструктор гарантируют, что OpenLibrary() и CloseLibrary() будут вызваны ровно один раз.

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

Деструкторы

Деструкторы вызываются каждый раз, когда стековый объект выходит из области действия (включая анонимные экземпляры и временные объекты, создаваемые компилятором) или когда для динамического объекта вызывается оператор delete. К деструкторам относится ряд малоизвестных фактов.

Порядок вызова

Деструкторы гарантированно вызываются в порядке, обратном порядку вызова конструкторов. Это означает, что сначала вызывается тело конструктора объекта, затем деструкторы переменных класса в порядке, обратном порядку их перечисления в объявлении класса, и наконец деструкторы базовых классов, начиная с последнего в списке наследования и кончая первым базовым первого базового и т.д.

Уничтожение глобальных объектов

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

Глобальные объекты уничтожаются при выходе из области действия main() или при вызове exit().

Невиртуальные деструкторы

C++ выбирает вызываемый деструктор по типу указателя на объект. Если указатель имеет тип base* (указатель на базовый класс), возникнут проблемы, если только деструктор класса не виртуален.

class Foo { public:

~Foo();

class Bar : public Foo { private:

int* numbers; public:

Bar() : numbers(new int[17]) {...} ~Bar();

Bar* b = new Bar;

delete b; Вызывает Bar::~Bar()

Foo* f = new Bar;

delete f; Ой! Вызывается Foo::Foo()!

При удалении f массив, на который ссылается переменная numbers, превращается в некое подобие Летучего Голландца, обреченного на вечные скитания в памяти. Чтобы избежать беды, достаточно объявить оба деструктора виртуальными; в этом случае независимо от типа указателя (кроме, конечно, void*) уничтожение будет начинаться с Bar: :~Ваг ().

Другая, более коварная проблема с невиртуальными деструкторами возникает при организации нестандартного управления памятью. Компилятор сообщает вашему перегруженному оператору размер уничтожаемого объекта - сюрприз! Для невиртуального деструктора этот размер может оказаться неверным. Представьте себе удивление вашей программы, когда ей сообщат, что объект имеет размер 20 байт, хотя на самом деле он равен 220 байтам! Разработчики компиляторов C++ любят похвастаться подобными проделками за кружкой пива после работы.

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

Прямой вызов деструкторов

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

class Foo { public:

~Foo();

Foo* f = new Foo; f->Foo::~Foo();

Позднее мы воспользуемся этой возможностью, а пока сохраните ее в своей коллекции C++.

Присваивание

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

Синтаксис и семантика присваивания

Для присваивания одного объекта другому используется оператор =. Foo f; Foo f1;

f1 = f;

Присваивание выполняется в третьей строке. Если бы f и f1 были целыми или чем-нибудь столь же простым, смысл этой строки был бы предельно ясен: содержимое области памяти, на которую