- •Содержание
- •Благодарности
- •Как читать эту книгу
- •Несколько слов о стиле программирования
- •Переменные и константы
- •const
- •Стековые и динамические объекты
- •Области действия и функции
- •Области действия
- •Перегрузка
- •Видимость
- •Типы и операторы
- •Конструкторы
- •Деструкторы
- •Присваивание
- •Перегрузка операторов
- •Что такое шаблоны и зачем они нужны?
- •Проблемы
- •Обходные решения
- •Синтаксис шаблонов
- •Параметризованные типы
- •Параметризованные функции
- •Параметризованные функции классов
- •Передача параметра
- •Шаблоны с несколькими параметрами
- •Долой вложенные параметризованные типы!
- •Наследование
- •Комбинации простых и параметризованных типов
- •Небезопасные типы в открытых базовых классах
- •Небезопасные типы в закрытых базовых классах
- •Небезопасные типы в переменных класса
- •Глава 4. Исключения
- •Обработка исключений в стандарте ANSI
- •Синтаксис инициирования исключений
- •Синтаксис перехвата исключений
- •Конструкторы и деструкторы
- •Нестандартная обработка исключений
- •Условные обозначения
- •Глава 5. Умные указатели
- •Глупые указатели
- •Умные указатели как идиома
- •Оператор ->
- •Параметризованные умные указатели
- •Иерархия умных указателей
- •Арифметические операции с указателями
- •Во что обходится умный указатель?
- •Применения
- •Разыменование значения NULL
- •Отладка и трассировка
- •Кэширование
- •Семантика ведущих указателей
- •Конструирование
- •Уничтожение
- •Копирование
- •Присваивание
- •Прототип шаблона ведущего указателя
- •Дескрипторы в C++
- •Что же получается?
- •Подсчет объектов
- •Указатели только для чтения
- •Указатели для чтения/записи
- •Интерфейсные указатели
- •Дублирование интерфейса
- •Маскировка указываемого объекта
- •Изменение интерфейса
- •Грани
- •Преобразование указываемого объекта в грань
- •Кристаллы
- •Вариации на тему граней
- •Инкапсуляция указываемого объекта
- •Проверка граней
- •Обеспечение согласованности
- •Грани и ведущие указатели
- •Переходные типы
- •Полиморфные указываемые объекты
- •Выбор типа указываемого объекта во время конструирования
- •Изменение указываемого объекта во время выполнения программы
- •Посредники
- •Функторы
- •Массивы и оператор []
- •Проверка границ и присваивание
- •Оператор [] с нецелыми аргументами
- •Имитация многомерных массивов
- •Множественные перегрузки оператора []
- •Виртуальный оператор []
- •Курсоры
- •Простой класс разреженного массива
- •Курсоры и разреженные массивы
- •Операторы преобразования и оператор ->
- •Итераторы
- •Активные итераторы
- •Пассивные итераторы
- •Что лучше?
- •Убогие, но распространенные варианты
- •Лучшие варианты
- •Итератор абстрактного массива
- •Операторы коллекций
- •Мудрые курсоры и надежность итераторов
- •Частные копии коллекций
- •Внутренние и внешние итераторы
- •Временная пометка
- •Пример
- •Тернистые пути дизайна
- •Транзакции
- •Отмена
- •Хватит?
- •Образы и указатели
- •Простой указатель образов
- •Стеки образов
- •Образы автоматических объектов
- •Образы указателей
- •Комбинации и вариации
- •Транзакции и отмена
- •Транзакции и блокировки
- •Класс ConstPtr
- •Класс LockPtr
- •Создание и уничтожение объектов
- •Упрощенное создание объектов
- •Отмена
- •Варианты
- •Вложенные блокировки
- •Взаимные блокировки и очереди
- •Многоуровневая отмена
- •Оптимизация объема
- •Несколько прощальных слов
- •Часть 3. Снова о типах
- •Гомоморфные иерархии классов
- •Взаимозаменяемость производных классов
- •Нормальное наследование
- •Инкапсуляция производных классов
- •Множественная передача
- •Двойная передача
- •Гетероморфная двойная передача
- •Передача более высокого порядка
- •Группировка передач и преобразования
- •Производящие функции
- •make-функции
- •Символические классы и перегруженные make-функции
- •Оптимизация с применением производящих функций
- •Локализованное использование производящих функций
- •Уничтожающие функции
- •Снова о двойной передаче: промежуточные базовые классы
- •Объекты классов
- •Информация о классе
- •Еще несколько слов об уничтожающих функциях
- •Определение класса по объекту
- •Представители
- •Основные концепции
- •Инкапсуляция указателей и указываемых объектов
- •Производящие функции
- •Ссылки на указатели
- •Неведущие указатели
- •Ведущие указатели
- •Снова о двойной передаче
- •Удвоенная двойная передача
- •Самомодификация и переходимость
- •Множественная двойная передача
- •Применение невидимых указателей
- •Кэширование
- •Распределенные объекты и посредники
- •Нетривиальные распределенные архитектуры
- •Часть 4. Управление памятью
- •Перегрузка операторов new и delete
- •Простой список свободной памяти
- •Наследование операторов new и delete
- •Аргументы оператора new
- •Конструирование с разделением фаз
- •Уничтожение с разделением фаз
- •Кто управляет выделением памяти?
- •Глобальное управление
- •Выделение и освобождение памяти в классах
- •Объекты классов и производящие функции
- •Управление памятью под руководством клиента
- •Управление памятью с применением ведущих указателей
- •Перспективы
- •Строительные блоки
- •Поблочное освобождение памяти
- •Скрытая информация
- •Подсчет ссылок
- •Базовый класс с подсчетом ссылок
- •Ведущие указатели с подсчетом ссылок
- •Дескрипторы с подсчетом ссылок
- •Трудности подсчета ссылок
- •Подсчет ссылок и ведущие указатели
- •Деление по классам
- •Деление по размеру
- •Деление по средствам доступа
- •Пространства стека и кучи
- •Поиск указателей
- •Мама, откуда берутся указатели?
- •Поиск указателей
- •Дескрипторы, повсюду дескрипторы
- •Общее описание архитектуры
- •Ведущие указатели
- •Вариации
- •Оптимизация в особых ситуациях
- •Алгоритм Бейкера
- •Пространства объектов
- •Последовательное копирование
- •Внешние объекты
- •Алгоритм Бейкера: уход и кормление в C++
- •Уплотнение на месте
- •Базовый класс VoidPtr
- •Пул ведущих указателей
- •Итератор ведущих указателей
- •Алгоритм уплотнения
- •Оптимизация
- •Перспективы
- •Глава 16. Сборка мусора
- •Доступность
- •Периметр
- •Внутри периметра
- •Анализ экземпляров
- •Перебор графа объектов
- •Сборка мусора по алгоритму Бейкера
- •Шаблон слабого дескриптора
- •Шаблон сильного дескриптора
- •Итераторы ведущих указателей
- •Перебор указателей
- •Оптимизация
- •Внешние объекты
- •Множественные пространства
- •Сборка мусора и уплотнение на месте
- •Нужно ли вызывать деструкторы?
- •Только для профессиональных каскадеров
- •Организация памяти
- •Поиск периметра
- •Перебор внутри периметра
- •Сборка мусора
- •Последовательная сборка мусора
- •Итоговые перспективы
233
{
if (!iterator->More())
Swap(); // Начать работу в другую сторону
else
{
VoidPtr* vp = iterator->Next(); if (vp->address >= inactive &&
vp->address < inactive + sizeof(*inactive))
{
void* new_space = active->Allocate(size); if (new_space == NULL)
throw(OutOfMemory()); memcpy(new_space, vp->address, vp->size); vp->address = new_space;
}
}
}
Функцию Copy1() необходимо вызывать как можно чаще, однако делать это можно в ходе нормальной работы программы. Новые объекты размещаются в активной половине, смешиваются со скопированными объектами, но это не приносит вреда. Поскольку перед копированием мы убеждаемся, что объект в данный момент находится в неактивном пространстве, созданные в активной половине объекты остаются без изменений.
Внешние объекты
Предположим, адрес объекта пришлось передать системной функции, которая ничего не знает ни о дескрипторах, ни о ведущих указателях. Такому объекту лучше оставаться на своем месте, пока системная функция не завершит свою работу!
SystemCall(&aString); // aString не следует перемещать до тех пор,
// пока его адрес остается в распоряжении системы
Прежде всего, совершенно неочевидно, как получить адрес объекта, поскольку рассматривавшиеся до настоящего момента ведущие указатели и дескрипторы не предоставляли прямого доступа к адресам объектов. Но даже если предположить, что такая способность была добавлена, приходится действовать осторожно. Первое побуждение — включить в ведущий указатель флаг, показывающий, что объект не должен перемещаться. Но тем самым вы швырнете гнилой помидор в алгоритм уплотнения; вам придется тщательно обходить этот объект, чтобы не скопировать что-нибудь поверх него. Более удачный выход — убрать объект из сжимаемого пространства на все время, пока он должен оставаться на фиксированном месте.
class Space { public:
void Externalize(VoidPtr* vp)
{
void* space = ::operator new(vp->size); memcpy(space, vp->address, vp->size); vp->address = space;
}
void Internalize(VoidPtr* vp)
{
void* space = Allocate(vp->size); memcpy(space, vp->address, vp->size); ::operator delete(vp->address); vp->address = space;
234
}
}
Функция Externalize() перемещает объект за пределы сжимаемого пространства; Internalize() возвращает его обратно. Алгоритм Copy1() будет нормально работать, поскольку не пытается перемещать объекты вне неактивной половины.
Этот способ также может применяться для передачи адреса переменной класса или this (см. ниже) некоторой функции класса или глобальной функции. Допустим, вам потребовалось организовать взаимодействие своих классов с коммерческой библиотекой, которая понятия не имеет о ваших хитроумных правилах уплотнения.
Помимо необходимости узнавать, когда внешний код перестал пользоваться вашим объектом, этот вариант может вызвать проблемы и при частой передаче адресов внешним функциям, поскольку копирование целого объекта из пространства памяти и обратно может обходиться довольно дорого.
Алгоритм Бейкера: уход и кормление в C++
Практическое использование описанных выше алгоритмов требует нескольких жестких ограничений. Алгоритм Бейкера для объектов С++ напоминает котенка, которого ваш ребенок приносит в дом и клянется «всегда-всегда» кормить и заботиться. Другими словами, все совершенно искренне клянутся соблюдать правила, а вам лучше надевать передник и идти за тряпкой.
Очереди операций и указатель this
Если на момент вызова Copy1() существует указатель this, то объект, на который он ссылается, может переместиться из одной половины в другую. При этом this будет радостно ссылаться на старую копию. Мы позаботились обо всех остальных стековых переменных и превратили их в дескрипторы. Теперь, чтобы получить доступ к объекту, им приходится разворачиваться на 180º и действовать через ведущий указатель. Возможно, силовое решение, которое работает, хотя и ненамного лучше — потребовать, чтобы функция Copy1() всегда вызывалась в самом конце функций класса:
class Foo { public:
void Fn()
{
// Код, который делает нечто осмысленное
VoidPtr::pool->Copy1();
}
};
Разумеется, все будет нормально лишь в том случае, если объект вызывавший Fn(), ну будет использовать свой указатель this после возвращения из Fn(). Не знаю, как вы, а лично я предпочитаю спать спокойно и не думать о том, как один из 2435 программистов, работающих с моей библиотекой классов, придумает способ все испортить.
Более достойное решение — сделать так, чтобы функция Copy1() вызывалась из некоторого цикла событий верхнего уровня. На самом деле нежелательно, чтобы в момент вызова Copy1() функции исчезающих объектов находились в стеке. В результате получается архитектура, которую я называю опосредованной (inside-out), — функция класса не выполняет работу сама, а создает объект-операцию (operational object) и направляет его в некоторую главную очередь. Это распространенное решение встречается во многих библиотеках классов.
class Operation { friend void MainLoop(); private:
static Queue<Operation> OperationQ; public:
virtual void DoSomething() = 0;
void Post() { OperationQ.Push(this); }
235
};
void MainLoop()
{
Operation* op;
while ((op = Operation::OperationQ.Pop()) != NULL)
{
op->DoSomething(); object_space->Copy1();
}
}
Если теперь объект захочет выполнить какое-нибудь действие, он не выполняет его сам, а создает класс, производный от Operation, и заносит его в очередь. Если обработка связана с итерациями, объект Operation продолжает направлять себя в очередь в конце каждого вызова DoSomething() до завершения итераций. Приведу краткий набросок традиционного подхода и опосредованной архитектуры:
// Традиционный способ сделать что-то void Foo::SomeOperation()
{
for (...) OnePass();
}
Если операция занимает много времени, перед вами возникают два неудобных варианта: не выполнять сборку мусора и уплотнение до завершения Foo::SomeOperation(), а следовательно, утратить многие преимущества от управления памятью; или косвенно вызвать Copy1() во время вызова Foo::SomeOperation(), а это небезопасно. Очередь операций предоставляет другое решение проблемы:
// Опосредованная архитектура с очередями операций class FooSomeOperation : public Operation } public:
virtual void DoSomething();
{
// Выполнить один проход if (еще не готово)
this->Post(); // Послать заново для следующего захода delete this;
}
};
void Foo::SomeOperation()
{
Operation* op = new FooSomeOperation(args); op->Post();
// op->DoSomething выполняет работу
}
Теперь функция Copy1() заведомо не будет вызвана в момент нахождения в стеке FooSomeOperation::DoSomething(). Подобные очереди операций так часто приносят пользу, что являются едва ли не стандартной возможностью объектно-ориентированных библиотек классов. Сколько библиотек — столько и вариаций (скажем, назначение приоритетов операций или возможность блокирования одних операций до завершения других), но во всех разновидностях встречается одна общая черта — максимальное освобождение стека на время периодического выполнения вспомогательных операций.
- #08.05.20136.97 Mб16W.H.Press, S.A.Teukolsky, W.T.Vetterling, B.P.Flannery - FORTRAN NUMERICAL RECIPES (Fortran 77) Vol.1.djvu
- #08.05.20133.43 Mб19W.H.Press, S.A.Teukolsky, W.T.Vetterling, B.P.Flannery - FORTRAN NUMERICAL RECIPES (Fortran 90) Vol.2.djvu
- #08.05.201310.54 Mб21W.H.Press, S.A.Teukolsky, W.T.Vetterling, B.P.Flannery - NUMERICAL RECIPES IN C.djvu
- #
- #
- #
- #
- #