- •Содержание
- •Благодарности
- •Как читать эту книгу
- •Несколько слов о стиле программирования
- •Переменные и константы
- •const
- •Стековые и динамические объекты
- •Области действия и функции
- •Области действия
- •Перегрузка
- •Видимость
- •Типы и операторы
- •Конструкторы
- •Деструкторы
- •Присваивание
- •Перегрузка операторов
- •Что такое шаблоны и зачем они нужны?
- •Проблемы
- •Обходные решения
- •Синтаксис шаблонов
- •Параметризованные типы
- •Параметризованные функции
- •Параметризованные функции классов
- •Передача параметра
- •Шаблоны с несколькими параметрами
- •Долой вложенные параметризованные типы!
- •Наследование
- •Комбинации простых и параметризованных типов
- •Небезопасные типы в открытых базовых классах
- •Небезопасные типы в закрытых базовых классах
- •Небезопасные типы в переменных класса
- •Глава 4. Исключения
- •Обработка исключений в стандарте ANSI
- •Синтаксис инициирования исключений
- •Синтаксис перехвата исключений
- •Конструкторы и деструкторы
- •Нестандартная обработка исключений
- •Условные обозначения
- •Глава 5. Умные указатели
- •Глупые указатели
- •Умные указатели как идиома
- •Оператор ->
- •Параметризованные умные указатели
- •Иерархия умных указателей
- •Арифметические операции с указателями
- •Во что обходится умный указатель?
- •Применения
- •Разыменование значения NULL
- •Отладка и трассировка
- •Кэширование
- •Семантика ведущих указателей
- •Конструирование
- •Уничтожение
- •Копирование
- •Присваивание
- •Прототип шаблона ведущего указателя
- •Дескрипторы в C++
- •Что же получается?
- •Подсчет объектов
- •Указатели только для чтения
- •Указатели для чтения/записи
- •Интерфейсные указатели
- •Дублирование интерфейса
- •Маскировка указываемого объекта
- •Изменение интерфейса
- •Грани
- •Преобразование указываемого объекта в грань
- •Кристаллы
- •Вариации на тему граней
- •Инкапсуляция указываемого объекта
- •Проверка граней
- •Обеспечение согласованности
- •Грани и ведущие указатели
- •Переходные типы
- •Полиморфные указываемые объекты
- •Выбор типа указываемого объекта во время конструирования
- •Изменение указываемого объекта во время выполнения программы
- •Посредники
- •Функторы
- •Массивы и оператор []
- •Проверка границ и присваивание
- •Оператор [] с нецелыми аргументами
- •Имитация многомерных массивов
- •Множественные перегрузки оператора []
- •Виртуальный оператор []
- •Курсоры
- •Простой класс разреженного массива
- •Курсоры и разреженные массивы
- •Операторы преобразования и оператор ->
- •Итераторы
- •Активные итераторы
- •Пассивные итераторы
- •Что лучше?
- •Убогие, но распространенные варианты
- •Лучшие варианты
- •Итератор абстрактного массива
- •Операторы коллекций
- •Мудрые курсоры и надежность итераторов
- •Частные копии коллекций
- •Внутренние и внешние итераторы
- •Временная пометка
- •Пример
- •Тернистые пути дизайна
- •Транзакции
- •Отмена
- •Хватит?
- •Образы и указатели
- •Простой указатель образов
- •Стеки образов
- •Образы автоматических объектов
- •Образы указателей
- •Комбинации и вариации
- •Транзакции и отмена
- •Транзакции и блокировки
- •Класс ConstPtr
- •Класс LockPtr
- •Создание и уничтожение объектов
- •Упрощенное создание объектов
- •Отмена
- •Варианты
- •Вложенные блокировки
- •Взаимные блокировки и очереди
- •Многоуровневая отмена
- •Оптимизация объема
- •Несколько прощальных слов
- •Часть 3. Снова о типах
- •Гомоморфные иерархии классов
- •Взаимозаменяемость производных классов
- •Нормальное наследование
- •Инкапсуляция производных классов
- •Множественная передача
- •Двойная передача
- •Гетероморфная двойная передача
- •Передача более высокого порядка
- •Группировка передач и преобразования
- •Производящие функции
- •make-функции
- •Символические классы и перегруженные make-функции
- •Оптимизация с применением производящих функций
- •Локализованное использование производящих функций
- •Уничтожающие функции
- •Снова о двойной передаче: промежуточные базовые классы
- •Объекты классов
- •Информация о классе
- •Еще несколько слов об уничтожающих функциях
- •Определение класса по объекту
- •Представители
- •Основные концепции
- •Инкапсуляция указателей и указываемых объектов
- •Производящие функции
- •Ссылки на указатели
- •Неведущие указатели
- •Ведущие указатели
- •Снова о двойной передаче
- •Удвоенная двойная передача
- •Самомодификация и переходимость
- •Множественная двойная передача
- •Применение невидимых указателей
- •Кэширование
- •Распределенные объекты и посредники
- •Нетривиальные распределенные архитектуры
- •Часть 4. Управление памятью
- •Перегрузка операторов new и delete
- •Простой список свободной памяти
- •Наследование операторов new и delete
- •Аргументы оператора new
- •Конструирование с разделением фаз
- •Уничтожение с разделением фаз
- •Кто управляет выделением памяти?
- •Глобальное управление
- •Выделение и освобождение памяти в классах
- •Объекты классов и производящие функции
- •Управление памятью под руководством клиента
- •Управление памятью с применением ведущих указателей
- •Перспективы
- •Строительные блоки
- •Поблочное освобождение памяти
- •Скрытая информация
- •Подсчет ссылок
- •Базовый класс с подсчетом ссылок
- •Ведущие указатели с подсчетом ссылок
- •Дескрипторы с подсчетом ссылок
- •Трудности подсчета ссылок
- •Подсчет ссылок и ведущие указатели
- •Деление по классам
- •Деление по размеру
- •Деление по средствам доступа
- •Пространства стека и кучи
- •Поиск указателей
- •Мама, откуда берутся указатели?
- •Поиск указателей
- •Дескрипторы, повсюду дескрипторы
- •Общее описание архитектуры
- •Ведущие указатели
- •Вариации
- •Оптимизация в особых ситуациях
- •Алгоритм Бейкера
- •Пространства объектов
- •Последовательное копирование
- •Внешние объекты
- •Алгоритм Бейкера: уход и кормление в C++
- •Уплотнение на месте
- •Базовый класс VoidPtr
- •Пул ведущих указателей
- •Итератор ведущих указателей
- •Алгоритм уплотнения
- •Оптимизация
- •Перспективы
- •Глава 16. Сборка мусора
- •Доступность
- •Периметр
- •Внутри периметра
- •Анализ экземпляров
- •Перебор графа объектов
- •Сборка мусора по алгоритму Бейкера
- •Шаблон слабого дескриптора
- •Шаблон сильного дескриптора
- •Итераторы ведущих указателей
- •Перебор указателей
- •Оптимизация
- •Внешние объекты
- •Множественные пространства
- •Сборка мусора и уплотнение на месте
- •Нужно ли вызывать деструкторы?
- •Только для профессиональных каскадеров
- •Организация памяти
- •Поиск периметра
- •Перебор внутри периметра
- •Сборка мусора
- •Последовательная сборка мусора
- •Итоговые перспективы
107
Выбор типа указываемого объекта во время конструирования
Если наш ведущий указатель может создать объект производного класса во время конструирования, почему бы не разрешить ему свободно выбрать нужный тип из нескольких производных классов?
// В файле Foo.cpp
class DeirvedFromFoo : public Foo { ... }; class AlsoDerivedFromFoo : public Foo { ... };
PFoo::PFoo(bool x) : foo(x ? new DerivedFromFoo : new AlsoDerivedFromFoo) {}
Вообще говоря, интерфейсный указатель может выбрать любой производный класс на основании сведений, доступных во время конструирования. Клиент об этом ничего не знает, поскольку все происходящее скрывается за интерфейсным указателем.
Изменение указываемого объекта во время выполнения программы
При желании интерфейсный указатель может сменить указываемый объект прямо во время выполнения программы.
class Foo; class PFoo { private:
Foo* foo; public:
PFoo();
void DoSomething(bool x); // Другие функции класса
};
void PFoo::DoSomething(bool x)
{
if (x) {
delete foo;
foo = new DerivedFromFoo;
}
Foo->DoSomething();
}
Пример уже встречался в предыдущей главе: при попытке неконстантного обращения к указываемому объекту указатель выбирал другую форму этого объекта. Такой подход работает вполне нормально, если не делать глупостей (например, получать адреса членов указываемого объекта).
Посредники
Интерфейсные указатели также помогают скрыть тот факт, что указываемый объект находится где-то в киберпространстве, а не сидит в памяти по соседству. В распределенных объектных системах такое происходит сплошь и рядом. Первая цель проектировщика — держать клиентские объекты в блаженном неведении; они не знают и знать не хотят, где находится указываемый объект — на расстоянии плевка или где-то на краю земли. Объект, который заменяет другой, удаленный объект, называется посредником (proxy). На эту тему тоже существует немало вариаций, но самая простая из них — локальное использование интерфейсного объекта или грани. Затем локальный посредник может воспользоваться дистанционными вызовами или другим механизмом отправки сообщений, подходящим для взаимодействия с оригиналом.
Эта концепция распространяется и на ситуации, в которых удаленный «объект» вообще не является объектом. Это может быть целое приложение, завернутое посредником в объектно-ориентированную оболочку, или, допустим, содержимое базы данных с библиотечными функциями «класса».
108
В самой идее внедрения «не объектно-ориентированного» кода в объекты С++ нет ничего нового или оригинального. Нас в первую очередь интересует уровень инкапсуляции. Что должен знать клиент о реальной ситуации? Умные указатели на основе операторов -> подходят плохо. Клиент должен знать интерфейс указываемого объекта; следовательно, он должен знать, существует ли указываемый объект, как устроен его интерфейс и т. д. Интерфейсные указатели, в том числе грани — более удачный вариант. Если ваша программа написана с применением интерфейсных указателей, вам будет намного проще вставить новый код, в котором некоторые из этих указателей реализуются в виде посредников. Проще, хотя и не совсем незаметно для клиента — пока. Помните базовую форму интерфейсного указателя с обязательным предварительным объявлением?
class |
Pointee; |
// Предварительное объявление |
class |
Interface { |
|
private:
Pointee* pointee; public:
// Функции класса
};
Проблема кроется в переменной pointee. Клиент должен знать, что указатель ссылается на нечто, даже если он понятия не имеет, на что именно. В части 3 мы попробуем устранить даже это ограничение, а пока будем считать его досадной мелочью.
В результате мы приходим к классическому компромиссу: понижение быстродействия интерфейсных указателей (с вынесенными (outline) функциями) за возможность кардинальных изменений реализации без модификации клиентского кода. В большинстве проектов и классов расходы с лихвой компенсируются ускорением цикла разработки.
Функторы
Напоследок мы познакомимся с одной диковинкой C++, которая называется функтором (functor). Функторы играют для функций ту же роль, что и интерфейсные указатели для объектов. Одна из проблем, вечно мучивших программистов на С — то, что все функции находятся в глобальном пространстве имен, то есть вызванная функция имеет доступ только к данным, хранящимся в ее аргументах, и глобальным переменным. Если передать адрес функции еще кому-то, то при вызове функции по адресу она не будет помнить, как выглядел окружающий мир во время получения ее адреса.
В таких языках, как Паскаль, эта проблема изящно решается получением замыкания (closure) на момент получения адреса функции.
procedure p(n: integer); var
procedure fn; begin
do_something(n);
end; begin
callback(@fn);
end;
В качестве аргумента процедура саllbackfn получает адрес другой процедуры. В данном примере ей передается адрес fn. При вызове fn из callbackfn первая имеет доступ к переменным,
находившимся в стеке в момент получения адреса. В нашем примере fn знает значение переменной n
на момент вызова саllbackfn.
Замыкания чрезвычайно полезны для обработки обратных вызовов (callback), поскольку функция обратного вызова кое-что знает о том, почему она была вызвана. В С вложенных функций не существует, а следовательно, замыкания невозможны — их место занимают функторы.
109
class Fn { private:
int number; public:
f(int n) : number(n) {}
void operator() () { do_something(number); }
};
void callbackfn(Fn);
void p(int n)
{
callbackfn(Fn(n));
}
void callbackfn(Fn fn)
{
// Что-то делаем
fn(); // Вызвать «функцию» fn с помощью функции operator()
}
Весь секрет кроется в двух выражениях. Функция callbackfn(Fn(n)) передает функции анонимный экземпляр класса Fn. Аргумент его конструктора содержит информацию, включаемую в «псевдозамыкание», которое поддерживается переменными класса Fn. Выражение fn(); может показаться обычным вызовом функции, но на самом деле в нем вызывается операторная функция operator() класса Fn. В свою очередь, эта функция вызывает глобальную функцию do_something с использованием данных замыкания. И кому после этого нужен Паскаль?
Операторная функция operator() может вызываться с произвольным набором аргументов. Чтобы добавить новые аргументы, укажите их во вторых скобках в объявлении класса. Также разрешается многократная перегрузка оператора () с разными сигнатурами. Ниже приведен тот же пример, в котором одна из версий операторной функции operator() вызывается с аргументом.
class Fn { private:
int number; public:
f(int n) : number(n) {}
void operator() () { do_something(number); } void operator() (char* s)
{
do_something(number);
cout << “Что-то делаю с ” << s << endl;
}
};
void callbackfn(Fn);
void p(int n)
{
callbackfn(Fn(n));
}
110
void callbackfn(Fn fn)
{
// Что-то делаем fn(“callbackfn”);
}
Эта маленькая идиома выглядит довольно изящно, однако того же эффекта можно добиться и без оператора ().
class Fn { private:
int number; public:
f(int n) : number(n) {}
void do_something() () { ::do_something(number); } void do_something() (char* s)
{
do_something(number);
cout << “Что-то делаю с ” << s << endl;
}
};
void callbackfn(Fn);
void p(int n)
{
callbackfn(Fn(n));
}
void callbackfn(Fn fn)
{
// Что-то делаем fn.do_something(“callbackfn”);
}
Как видите, с таким же успехом можно воспользоваться именем любой функции класса. Единственная причина для использования оператора () — в том, что он предельно ясно выражает ваши намерения. Если класс существует лишь для того, чтобы обслуживать обратные вызовы подобного рода, пользуйтесь оператором (); в противном случае пользуйтесь обычными функциями класса.