- •Содержание
- •Благодарности
- •Как читать эту книгу
- •Несколько слов о стиле программирования
- •Переменные и константы
- •const
- •Стековые и динамические объекты
- •Области действия и функции
- •Области действия
- •Перегрузка
- •Видимость
- •Типы и операторы
- •Конструкторы
- •Деструкторы
- •Присваивание
- •Перегрузка операторов
- •Что такое шаблоны и зачем они нужны?
- •Проблемы
- •Обходные решения
- •Синтаксис шаблонов
- •Параметризованные типы
- •Параметризованные функции
- •Параметризованные функции классов
- •Передача параметра
- •Шаблоны с несколькими параметрами
- •Долой вложенные параметризованные типы!
- •Наследование
- •Комбинации простых и параметризованных типов
- •Небезопасные типы в открытых базовых классах
- •Небезопасные типы в закрытых базовых классах
- •Небезопасные типы в переменных класса
- •Глава 4. Исключения
- •Обработка исключений в стандарте ANSI
- •Синтаксис инициирования исключений
- •Синтаксис перехвата исключений
- •Конструкторы и деструкторы
- •Нестандартная обработка исключений
- •Условные обозначения
- •Глава 5. Умные указатели
- •Глупые указатели
- •Умные указатели как идиома
- •Оператор ->
- •Параметризованные умные указатели
- •Иерархия умных указателей
- •Арифметические операции с указателями
- •Во что обходится умный указатель?
- •Применения
- •Разыменование значения NULL
- •Отладка и трассировка
- •Кэширование
- •Семантика ведущих указателей
- •Конструирование
- •Уничтожение
- •Копирование
- •Присваивание
- •Прототип шаблона ведущего указателя
- •Дескрипторы в C++
- •Что же получается?
- •Подсчет объектов
- •Указатели только для чтения
- •Указатели для чтения/записи
- •Интерфейсные указатели
- •Дублирование интерфейса
- •Маскировка указываемого объекта
- •Изменение интерфейса
- •Грани
- •Преобразование указываемого объекта в грань
- •Кристаллы
- •Вариации на тему граней
- •Инкапсуляция указываемого объекта
- •Проверка граней
- •Обеспечение согласованности
- •Грани и ведущие указатели
- •Переходные типы
- •Полиморфные указываемые объекты
- •Выбор типа указываемого объекта во время конструирования
- •Изменение указываемого объекта во время выполнения программы
- •Посредники
- •Функторы
- •Массивы и оператор []
- •Проверка границ и присваивание
- •Оператор [] с нецелыми аргументами
- •Имитация многомерных массивов
- •Множественные перегрузки оператора []
- •Виртуальный оператор []
- •Курсоры
- •Простой класс разреженного массива
- •Курсоры и разреженные массивы
- •Операторы преобразования и оператор ->
- •Итераторы
- •Активные итераторы
- •Пассивные итераторы
- •Что лучше?
- •Убогие, но распространенные варианты
- •Лучшие варианты
- •Итератор абстрактного массива
- •Операторы коллекций
- •Мудрые курсоры и надежность итераторов
- •Частные копии коллекций
- •Внутренние и внешние итераторы
- •Временная пометка
- •Пример
- •Тернистые пути дизайна
- •Транзакции
- •Отмена
- •Хватит?
- •Образы и указатели
- •Простой указатель образов
- •Стеки образов
- •Образы автоматических объектов
- •Образы указателей
- •Комбинации и вариации
- •Транзакции и отмена
- •Транзакции и блокировки
- •Класс ConstPtr
- •Класс LockPtr
- •Создание и уничтожение объектов
- •Упрощенное создание объектов
- •Отмена
- •Варианты
- •Вложенные блокировки
- •Взаимные блокировки и очереди
- •Многоуровневая отмена
- •Оптимизация объема
- •Несколько прощальных слов
- •Часть 3. Снова о типах
- •Гомоморфные иерархии классов
- •Взаимозаменяемость производных классов
- •Нормальное наследование
- •Инкапсуляция производных классов
- •Множественная передача
- •Двойная передача
- •Гетероморфная двойная передача
- •Передача более высокого порядка
- •Группировка передач и преобразования
- •Производящие функции
- •make-функции
- •Символические классы и перегруженные make-функции
- •Оптимизация с применением производящих функций
- •Локализованное использование производящих функций
- •Уничтожающие функции
- •Снова о двойной передаче: промежуточные базовые классы
- •Объекты классов
- •Информация о классе
- •Еще несколько слов об уничтожающих функциях
- •Определение класса по объекту
- •Представители
- •Основные концепции
- •Инкапсуляция указателей и указываемых объектов
- •Производящие функции
- •Ссылки на указатели
- •Неведущие указатели
- •Ведущие указатели
- •Снова о двойной передаче
- •Удвоенная двойная передача
- •Самомодификация и переходимость
- •Множественная двойная передача
- •Применение невидимых указателей
- •Кэширование
- •Распределенные объекты и посредники
- •Нетривиальные распределенные архитектуры
- •Часть 4. Управление памятью
- •Перегрузка операторов new и delete
- •Простой список свободной памяти
- •Наследование операторов new и delete
- •Аргументы оператора new
- •Конструирование с разделением фаз
- •Уничтожение с разделением фаз
- •Кто управляет выделением памяти?
- •Глобальное управление
- •Выделение и освобождение памяти в классах
- •Объекты классов и производящие функции
- •Управление памятью под руководством клиента
- •Управление памятью с применением ведущих указателей
- •Перспективы
- •Строительные блоки
- •Поблочное освобождение памяти
- •Скрытая информация
- •Подсчет ссылок
- •Базовый класс с подсчетом ссылок
- •Ведущие указатели с подсчетом ссылок
- •Дескрипторы с подсчетом ссылок
- •Трудности подсчета ссылок
- •Подсчет ссылок и ведущие указатели
- •Деление по классам
- •Деление по размеру
- •Деление по средствам доступа
- •Пространства стека и кучи
- •Поиск указателей
- •Мама, откуда берутся указатели?
- •Поиск указателей
- •Дескрипторы, повсюду дескрипторы
- •Общее описание архитектуры
- •Ведущие указатели
- •Вариации
- •Оптимизация в особых ситуациях
- •Алгоритм Бейкера
- •Пространства объектов
- •Последовательное копирование
- •Внешние объекты
- •Алгоритм Бейкера: уход и кормление в C++
- •Уплотнение на месте
- •Базовый класс VoidPtr
- •Пул ведущих указателей
- •Итератор ведущих указателей
- •Алгоритм уплотнения
- •Оптимизация
- •Перспективы
- •Глава 16. Сборка мусора
- •Доступность
- •Периметр
- •Внутри периметра
- •Анализ экземпляров
- •Перебор графа объектов
- •Сборка мусора по алгоритму Бейкера
- •Шаблон слабого дескриптора
- •Шаблон сильного дескриптора
- •Итераторы ведущих указателей
- •Перебор указателей
- •Оптимизация
- •Внешние объекты
- •Множественные пространства
- •Сборка мусора и уплотнение на месте
- •Нужно ли вызывать деструкторы?
- •Только для профессиональных каскадеров
- •Организация памяти
- •Поиск периметра
- •Перебор внутри периметра
- •Сборка мусора
- •Последовательная сборка мусора
- •Итоговые перспективы
210
}
*((void**)space) = fl->top_of_list; fl->top_of_list = space;
}
Функции Allocate() и Deallocate() вызываются из перегруженных операторов new и delete соответственно. Такой подход предельно упрощен, но работает он неплохо. Вы можете воспользоваться им для любого сочетания классов, и он будет работать с производными классами, в которых добавились новые переменные. Он также может использоваться в схеме управления памятью на базе ведущих указателей. Существуют многочисленные усовершенствования, которые можно внести в показанную основу:
•Ограничить размеры блоков числами, кратными некоторому числу байт, степенями 2 или числами Фибоначчи.
•Воспользоваться более эффективной структурой данных, чем связанный список списков — возможно, бинарным деревом или даже массивом, если диапазон размеров невелик.
•Предоставить функцию Flush(), которая при нехватке памяти удаляет все содержимое списков.
•В функции Allocate() при отсутствии в списке свободного места заданного размера выделить память под массив блоков этого размера вместо одного блока.
Подсчет ссылок
Подсчет ссылок основан на простой идее — мы следим за количеством указателей, ссылающихся на объект. Когда счетчик становится равным 0, объект удаляется. Звучит просто, не правда ли? В определенных условиях все действительно просто, но подсчет ссылок обладает довольно жесткими ограничениями, которые снижают его практическую ценность.
Базовый класс с подсчетом ссылок
Начнем с абстрактного базового класса, от которого можно создать производный класс с подсчетом ссылок. Базовый класс содержит переменную, в которой хранится количество вызовов функции Grab() за вычетом количества вызовов функции Release().
class RefCount { |
|
private: |
|
unsigned long count; |
// Счетчик ссылок |
public: |
|
RefCount() : count(0) {} |
|
RefCount(const RefCount&) : count(0) {} |
|
RefCount& operator=(const RefCount&) |
|
{ return *this; } |
// Не изменяет счетчик |
virtual ~RefCount() {} |
// Заготовка |
void Grab() { count++; } void Release()
{
if (count > 0) count --;
if (count == 0) delete this;
}
};
Пока клиентский код правильно вызывает функции Grab() и Release(), все работает абсолютно надежно. Каждый раз, когда клиент получает или копирует адрес объекта, производного от RefCount, он вызывает Grab(). Когда клиент гарантирует, что адрес больше не используется, он вызывает Release(). Если счетчик падает до 0 — бац! Нет больше объекта!
211
Недостаток такой методики очевиден — она слишком полагается на соблюдение всех правил программистом. Можно сделать получше.
Укзатели с подсчетом ссылок
Давайте усовершенствуем базовый класс RefCount и создадим модифицированный шаблон умного указателя для любых классов, производных от RefCount.
template <class Type>
class CP { // “Указатель с подсчетом ссылок” private:
Type* pointee; public:
CP(Type* p) : pointee(p) { pointee->Grab(); } CP(const CP<Type>& cp) : pointee(cp.pointee)
{ pointee->Grab(); } ~CP() { ponintee->Release(); }
CP<Type>& operator=(const CP<Type>& cp)
{
if (this == &cp) return *this; pointee->Release();
pointee = cp.pointee; pointee->Grab(); return *this;
}
Type* operator->() { return pointee; }
};
Если весь клиентский код будет обращаться к классам с подсчетом ссылок через этот или аналогичный шаблон, подсчет ссылок осуществляется автоматически. При каждом создании новой копии указателя происходит автоматический вызов Grab(). При каждом уничтожении указателя его деструктор уменьшает значение счетчика. Единственная опасность заключается в том, что клиент обойдет умный указатель. С этой проблемой можно справиться с помощью производящих функций целевого класса.
class Foo : public RefCount { private:
Foo(); // Вместе с другими конструкторами public:
static CP<Foo> make(); // Создаем экземпляр
// Далее следует интерфейс Foo
};
Тем самым мы гарантируем, что доступ к Foo будет осуществляться только через указатель с подсчетом ссылок. Обратите внимание: это не ведущий, а самый обычный умный указатель.
Ведущие указатели с подсчетом ссылок
Даже если вы не хотите модифицировать конкретный класс, чтобы сделать его производным от RefCount (например, если он имеет критические требования по быстродействию и объему или входит в коммерческую библиотеку классов), не отчаивайтесь. Подсчет ссылок можно переместить в ведущий указатель.
template <class Type>
class CMP { // “Ведущий указатель с подсчетом ссылок” private:
Type* pointee; unsigned long count;
212
public:
CMP() : pointee(new Type), count(0) {} CMP(const CMP<Type>& cmp)
: pointee(new Type(*(cmp.pointee))), count(0) {} ~CMP() { delete pointee; } // Независимо от счетчика CMP<Type>& operator=(const CMP<Type>& cmp)
{
if (this == &cmp) return *this; delete pointee;
pointee = new Type(*(cmp.pointee)); return *this;
}
Type* operator->() const { return pointee; } void Grab() { count++; }
void Release()
{
if (count > 0) count--; if (count <= 0)
{
delete pointee; delete this;
}
}
};
В сущности, это равносильно объединению старого шаблона ведущего указателя с базовым классом RefCount. Подсчет ссылок уже не выделяется в отдельный класс, но зато нам снова приходится полагаться на правильное поведение программистов — существ, к сожалению, несовершенных.
Дескрипторы с подсчетом ссылок
На сцену выходит нечто новое: дескриптор (handle) с подсчетом ссылок. По отношению к шаблону CMP он станет тем же, чем CP был для RefCount, — то есть он автоматически вызывает функции Grab() и Release() в своих конструкторах, деструкторе и операторе =.
template <class Type>
class CH { // “Дескриптор с подсчетом ссылок” private:
CMP<Type>* pointee; public:
CH(CMP<Type>* p) : pointee(p) { pointee->Grab(); }
CH(const CH<Type>& ch) : pointee(ch.pointee) { pointee->Grab(); } ~CH() { pointee->Release(); }
CH<Type>& operator=(const CH<Type>& ch)
{
if (this == &ch) return *this;
if (pointee == ch.pointee) return *this; pointee->Release();
pointee = ch.pointee; pointee->Grab(); return *this;
}
213
CMP<Type> operator->() { return *pointee; }
};
Если использовать дескрипторы в сочетании с ведущими указателями, можно выбрать, для каких экземпляров класса следует подсчитывать ссылки, а какие экземпляры должны управляться другим способом.
Трудности подсчета ссылок
Все выглядит так просто; однако без ложки дегтя дело все же не обходится. Подсчет ссылок обладает одним очень распространенным недостатком — зацикливанием. Представьте себе ситуацию: объект А захватил объект В (то есть вызвал для него функцию Grab()), а объект В сделал то же самое для объекта А. Ни на А, ни на В другие объекты не ссылаются. Здравый смысл подсказывает, что А следует удалить вместе с В, но они продолжают существовать, поскольку их счетчики ссылок так и не обнуляются. Обидно, да?
Подобное зацикливание возникает сплошь и рядом. Оно может относиться не только к парам объектов, но и целым подграфам. A -> B -> C -> D -> A, но никто за пределами этой группы не ссылается ни на один из этих объектов. Группа словно плывет на «Летучем Голландце», построенном в эпоху высоких технологий и обреченном на вечные скитания в памяти. Существует несколько стратегий борьбы с зацикливаниями. Все они не обладают особой универсальностью, и в вашей конкретной ситуации это может привести к отказу от подсчета ссылок. Как правило, встречаясь с проблемой циклических ссылок, стоит рассмотреть более хитроумные приемы, описанные в двух последних главах. Как видите, мысль об отказе от подсчета ссылок приходит довольно быстро.
Декомпозиция
Предположим, А захватывает В, а затем В захватывает некоторый компонент А:
class A { private:
Foo* foo; B* b;
};
Если сделать так, чтобы В выполнял захват в функции foo, проблем не возникает. Когда последняя ссылка на A ликвидируется, его счетчик становится равным 0, поскольку В его не увеличивает. Для этого придется проявить некоторую изрядную изобретательность при кодировании, к тому же дизайн сильно зависит от особенностей конкретных объектов, но на удивление часто он решает проблему зацикливания.
Сильные и слабые дескрипторы
Предположим, ссылка А на В создавалась через Grab(), а ссылка В на А — нет. В тот момент, когда исчезнет последняя ссылка на А из внешнего мира, подсчет ссылок для обоих объектов пары прекратит их существование. На этой идее основано различие между сильными (strong) и слабыми (weak) дескрипторами или указателями с подсчетом ссылок. Описанный выше шаблон CH будет относиться к сильным дескрипторам, поскольку поддерживает счетчик ссылок. Обычный шаблон дескриптора (без вызова Grab и Release) будет относиться к слабым. Если спроектировать архитектуру объектов так, чтобы не существовало циклических подграфов, содержащих исключительно сильные дескрипторы, то вся схема подсчета ссылок снова возвращается в игру. Самая распространенная ситуация с таким решением — иерархия целое/часть, в которой пары удаляются при удалении целого. Целые поддерживают сильные ссылки, части — слабые.
Подсчет ссылок и ведущие указатели
Одно из самых распространенных и полезных применений подсчета ссылок заключается в управлении ведущими указателями. В предыдущих главах эта тема упоминалась неоднократно. Дескрипторы живут в стеке и потому автоматически уничтожаются при сборке мусора, выполняемой компилятором. Однако ведущие указатели (по тем же причинам, что и объекты) обычно приходится создавать в куче. Как узнать, когда следует удалять ведущий указатель? Подсчет ссылок упрощает эту задачу.