40
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();
};
41
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 были целыми или чем-нибудь столь же простым, смысл этой строки был бы предельно ясен: содержимое области памяти, на которую
42
ссылается f, копируется в область памяти, на которую ссылается f1. Только и всего. Но если Foo относится к нетривиальному классу, в C++ все заметно усложняется. В приведенном примере компилятор предоставляет оператор = по умолчанию, который вызывается для выполнения фактического копирования. Как и с конструкторами копий, вы можете спокойно сидеть и смотреть, как компилятор вкалывает за вас, или написать свой собственный оператор =. То, что делает версия по умолчанию, вам может и не понравиться, особенно в момент освобождения памяти деструктором класса.
class String { private:
char* s; public:
String(char*);
~String();
void Dump(ostream& os);
};
String::String(char* str) : s(NULL)
{
if (str == NULL) { // NULL означает пустую строку s = new char[1];
*s = ‘\0’;
}
else {
s = new char[strlen(str) + 1]; strcpy(s, str);
}
}
String::~String()
{
delete s;
}
void String::Dump(ostream& os)
{
os << “\”” << s << “\””;
}
String* s1 = new String(“Hello”); String* s2 = new String(“Goodbye”);
s2 = s1; |
|
|
delete |
s1; |
// Память освободилась, вроде все нормально... |
s2->Dump(); |
// Облом! Ха-ха-ха! |
|
delete |
s2; |
// Помогите, убивают! Ха-ха-ха! |
По умолчанию компилятор копирует содержимое s2->s поверх содержимого s1->s. При этом копируется значение указателя, а не символы, поэтому после присваивания возникают две большие проблемы. Два разных объекта ссылаются на одну область памяти, и никто не ссылается на копию
Goodbye, созданную командой String* s2 = new String( "Goodbye");. Дальше — больше; при удалении s1 деструктор освобождает область памяти, на которую ссылается s1. Однако на эту память продолжает ссылаться указатель s2->s. Попытка вывести s2->s дает совершенно безумные результаты. «Комедия ошибок» достигает кульминации при попытке удалить s2, поскольку менеджер памяти попытается освободить ранее освобожденную область. Чего только не бывает в C++!
43
Разумеется, та же проблема возникает и при создании копий. Конструктор копий по умолчанию копирует указатель, а не данные, на которые он ссылается. По этой причине конструктор копий и оператор = обычно перегружаются одновременно.
Присваивание и инициализация
Мы уже обсуждали, чем инициализация отличается от присваивания, но эта тема настолько важна, что я повторю еще раз. Если объект слева от оператора = был сконструирован заранее, = означает присваивание. Если в этом выражении он конструируется впервые, речь идет о конструировании и конструкторах. В следующем примере первая строка с символом = выполняет инициализацию и вызывает конструктор копий. Вторая строка выполняет присваивание и вызывает оператор =.
Foo f; |
|
|
Foo f1 |
= f; |
// Инициализация; f1 еще не существует |
f1 = f; |
|
// Присваивание: объект f1 уже сконструирован |
Присваивание по умолчанию
Оператор = по умолчанию, как и конструктор копий по умолчанию, ведет себя четко определенным образом. Как и конструктор копий, который рекурсивно вызывает другие конструкторы копий, оператор = по умолчанию не ограничивается простым копированием битов из одного объекта в другой. Последовательность его действий выглядит так:
1. Присваивание для базовых классов выполняется в порядке их перечисления в списке наследования. При этом используются перегруженные операторы = базовых классов или в случае их отсутствия — оператор = по умолчанию.
2.Присваивание переменных класса выполняется в порядке их перечисления в объявлении класса. При этом используются перегруженные операторы = базовых классов или в случае их отсутствия — оператор = по умолчанию.
Эти правила применяются рекурсивно. Как и в случае с конструкторами, сначала выполняется присваивание для первого базового класса первого базового класса и т. д.
Перегрузка оператора =
Перегрузка оператора = практически не отличается от перегрузки всех остальных операторов. Пока нас интересует сигнатура оператора =, которая выглядит так: Х& X::operator=(const X&).
class String { private:
char* s; public:
String(char*);
~String();
String(const String&); // Возможно, тоже решает проблему
String& operator=(const String&); void Dump(ostream& os);
};
String::String(char* s) : s(NULL)
{
if (str == NULL) { // NULL означает пустую строку s = new char[1];
*s = ‘\0’;
}
else {
s = new char[strlen(str) + 1]; strcpy(s, str);
44
}
}
String::~String()
{
delete s;
}
String::String(const String& s1) : s(NULL)
{
s = new char[strlen(s1.s) + 1]; strcpy(s, s1.s);
}
String& String::operator=(const String& s1)
{
if (this == &s1) return *this;
delete |
s; |
// Уничтожить предыдущее значение |
s = new char[strlen(s1.s) + 1]; |
||
strcpy(s, s1.s); |
||
return |
*this; |
|
}
void String::Dump(ostream& os)
{
os << “\”” << s << “\””;
}
Конструктор копий и оператор = вместо простого копирования адреса теперь создают копию новой строки. Деструктор стал безопасным, и миру ничего не угрожает.
Ниже показан обобщенный вид оператора =, который стоит занести в долговременную память (не компьютерную, а вашу собственную):
1. Убедитесь, что не выполняется присваивание вида x=x;. Если левая и правая части ссылаются на один объект, делать ничего не надо. Если не перехватить этот особый случай, то следующий шаг уничтожит значение до того, как оно будет скопировано.
2.Удалите предыдущие данные.
3.Скопируйте значение.
4.Возвратите указатель *this.
Оператор = возвращает *this, чтобы стало возможным вложенное присваивание вида а=b=с. В C++, как и в С, значением этого выражения является присваиваемая величина. Выражение интерпретируется справа налево, как а=(b=с).
А теперь — плохие новости. Как и в случае с конструкторами копий, при перегрузке оператора = C++ умывает руки и отправляется домой. Если вы перегрузили оператор =, то на вас ложится ответственность за выполнение присваивания для переменных и базовых классов; по умолчанию базовые классы и переменные левостороннего объекта остаются без изменений.
Присваивание для переменных класса
Иногда переменные класса относятся к простейшим типам данных (например, int), и тогда присваивание выполняется с помощью оператора =, предоставленного компилятором. Иногда (например, для класса String) их приходится копировать вручную. В остальных случаях переменные относятся к какому-нибудь нетривиальному классу. Лучший выход из положения — присвоить чтонибудь таким переменным. При этом компилятор определяет, существует ли для переменной перегруженный оператор = или он должен использовать свой собственный вариант по умолчанию.
class Foo {
45
public:
Foo& operator=(const Foo&);
};
class Bar { public:
// Оператор = не перегружен
};
class FooBar { private:
Foo f; Bar b;
public:
FooBar& operator=(const FooBar&);
};
FooBar& FooBar::operator=(const FooBar& fb)
{
if (this == &fb) return *this; |
||
f = fb.f; |
// Используется |
перегруженный оператор = класса Foo |
f = fb.b; |
// Используется |
оператор = по умолчанию |
return *this; |
|
|
}
Применяя эту методику, вы не заботитесь о том, существует ли для переменной перегруженный оператор =. Об этом должен думать компилятор.
Присваивание для базовых классов
Присваивание для базовых классов сопряжено с некоторыми синтаксическими ухищрениями. Если вы никогда их не видели, вероятно, на поиск правильной комбинации уйдет немало времени. Выглядит она так:
class Foo {...} |
|
class Bar : public Foo { |
|
public: |
|
Bar& operator=(const Bar&); |
|
}; |
|
Bar& Bar::operator=(const Bar& b) |
|
{ |
|
if (this == &b) return *this; |
|
this->Foo::operator=(b); |
// Чего-чего? |
return *this; |
|
} |
|
Другие варианты, которые могут придти в голову (например, *((Foo)this)=b;), не работают — поверьте мне на слово. Все они создают временные копии. Показанный вариант работает, поскольку компилятор знает, как преобразовать Bar в Foo в аргументе. Он работает независимо от того, перегружали вы Foo::operator= или нет. Даже если не перегружали, оператор все равно присутствует, и его можно вызвать по полному имени Foo::operator=.
Другие сигнатуры оператора =
Оператор = не ограничен одной сигнатурой. Его можно перегрузить так, чтобы в правой части присваивания мог стоять аргумент любого другого типа. Сигнатура Х& X::operator=(const Х&) выделяется на общем фоне тем, что компилятор предоставляет ее версию по умолчанию и использует эту сигнатуру в стандартном алгоритме рекурсивного присваивания.