Идиомы и стили С++ - [13]

1. Определяем ВСЕ необходимые конструкторы.

2. ВСЕ конструкторы кладем в private или protected.

3. Рисуем производящую функцю.

Как писал Зощенко, "стою, любуюсь крепкой тарой".

Есть еще один способ. Вы будете смеяться. Или плакать. Придёте в возбуждение. Так что зажгите сигарету загодя и хорошенько затянитесь.

1. Защищаем… деструктор!

2. Рисуем разрушающую функцию.

Vous savez, деструктор только один, да к тому же виртуальный. Эх, жалко нет метакласса… да и зачем нам метакласс, я же читать не умею (авторская разрядка здесь)!

Нужно только помнить, что разрушение объекта через delete и через явный вызов деструктора есть не одно и то же. Об этом позже, когда будем ковырять память.(Автор после разрядки мгновенно засыпает.)

Шаг 18 - Управление памятью.

Больше нет возможности обходить эту тему. Это слишком важно. Долго не хотел браться за нее, но она сама взялась за меня.В управлении памятью одна из самых больших проблем (для меня) состоит в том,что у авторов книг по C++ в этом месте случается как бы легкий интеллектуальный сдвиг… И их объяснения становятся похожи на прения на слете экстрасенсов, чародеев и магов. Или как если бы кто взялся объяснять герундий английского языка мне (Альберту Махмутову) по китайски.

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

Вспомните Шаг 12. Что делается, когда компилятор видит ключевое слово new? Сначала выделяется память, и компилятор получает указатель на нее, потом вызывается конструктор; ясно, что где-то в глубине кода конструктор получает указатель на свежую, сырую память, исполняет себя, а потом возвращает указатель обратно клиенту. Как выделяется сырая память? На то есть оператор operator new.

Вот его прототип:

void* operator new(size_t);

Ничего сложного. Несколько необычно получает параметр, правда, но это только на первый взгляд, на то он и оператор. Параметр - это размер объекта; похоже на то, как если бы мы написали (но неверно разумеется):

CClass* cc = operator new(sizeof(CClass));

Зато мы можем перегрузить operator new (что не удивительно), да к тому же добавить параметров (что уже лучше). Главное, чтобы первый параметр был все равно size_t - размер объекта, а то из спецификаци языка вылетим. Обратите внимание - перегружается оператор operator new(), а не ключевое слово new, оно же элемент синтаксиса, можно сказать. Прототип перегрузки и пример использования:

void* operator new(size_t, int);
//                          V
//                --‹-‹-‹---
//                ¦
//                V
CClass* cc = new(234) CClass;

У меня ни малейшего понятия, зачем Вы суете сюда int. Лично у меня на параметр свои виды. Я собираюсь пульнуть туда как раз тот указатель, который надо вернуть. А больше ничего не делать. Чтоб память НЕ ВЫДЕЛЯЛАСЬ. Потому что я намереваюсь ее раздобыть сам.

// Прототип оператора
void* operator new(size_t, void* buffer) {return buffer}
// Использование. Получаем шмат памяти
char* piece_of_memory[1000000000000];
// делаем вызов.
CClass* cc = new(piece_of_memory) CClass;

Мрачная картина. Душераздирающее зрелище. Но результат на лице: Это - менеджер памяти. Самый натуральный. Буферизованный оператор operator new. Виртуальный конструктор (не знаю почему; учитывая, что в официальных справочниках Microsoft разъясняется, что СИСТЕМНЫЙ диск это тот, с которого ЗАГРУЖАЕМСЯ, а ЗАГРУЗОЧНЫЙ тот, на котором СИСТЕМА, меня мало что удивляет в терминологиях).

Шаг 19 - Управление памятью. Продолжение 1.

Бог: "Я стер всякую жизнь. Впочем, я ничего не уничтожил. Я просто воссоединил в Себе частицы Себя. У меня на планете было множество типов с безумными глазами, которые болтали насчет слияния со Мной. Вот они и слились."

Кармоди: "Им это понравилось?"

Бог: "Откуда я знаю?"

Р. Шекли. Координаты чудес.

А что случается, когда компилятор видит ключевое слово delete? А кстати то же самое, только в обратном порядке. Сначала вызывает деструктор, потом вызывает operator delete(), прототип коего:

void operator delete (void* to_free_mem);

Параметр есть указатель на освобождаемую память. Да, но в нашем примере НЕ НАДО ничего освобождать. Мы сами добыли память, сами и освободим. Что делать? Вообще не употреблять delete (ключевое слово, не оператор). А употребить только деструктор.

ourObject-›~CClass();

Но с другой стороны, не следует навечно занимать память.Это нехорошо. Отдавать нужно так же, как и брали. Брали malloc() - отдаем через free(). Брали в стеке - ничего не делаем, само освободится. А может, брали через operator new() - тогда освобождаем через operator delete(). Вы наверное поняли, что сырую память можно взять через чистый оператор operator new():

// взяли память
char* piece_of_memory = operator new(100000000);
// положили на место.
operator delete (piece_of_memory);

Вроде управились со всем. Надо только запомнить, что всегда (превсегда) выделение и освобождение памяти должно идти только через комплементарные пары функций и механизмов. Потому что они (механизмы) совершенно друг друга не понимают. И память, выделенная через