78
Во что обходится умный указатель?
Объект класса, не содержащего виртуальных функций, занимает столько места, сколько необходимо для хранения всех его переменных. В рассмотренных выше умных указателях используется всего одна переменная — *-указатель; то есть размер умного указателя в точности совпадает с размером встроенного указателя. Хороший компилятор C++ должен специальным образом обрабатывать тривиальные подставляемые функции, в том числе и находящиеся в шаблоне умного указателя.
template <class Type> class Ptr {
private:
Type* pointer; public:
Ptr() : pointer(NULL) {} Ptr(Type* p) : pointer(p) {}
operator Type*() { return pointer; } Type* operator->() { return pointer; }
};
В частности, использование оператора -> из этого шаблона не должно требовать никаких дополнительных вычислений по сравнению со встроенными указателями. Как всегда, обращайте особое внимание на слова хороший и должно. В хорошей реализации описанные выше умные указатели не требуют никаких дополнительных расходов. По крайней мере, хуже пока не стало.
Применения
Умные указатели — существа на редкость полезные, и мы проведем немало времени, изучая их применение на практике. Для простых умных указателей, рассматриваемых в этой главе, находятся столь же простые, но мощные применения.
Разыменование значения NULL
Рассмотрим одну из вариаций на тему умных указателей:
template <class Type> class SPN {
private:
Type* pointer; public:
SPN() : pointer(NULL) {} SPN(Type* p) : pointer(p) {}
operator Type*() { return pointer; } Type* operator->()
{
if (pointer == NULL) {
cerr << “Dereferencing NULL!” << endl; pointer = new Type;
}
return pointer;
}
При попытке вызвать оператор -> для указателя pointer, равного NULL, в поток stderr выводится сообщение об ошибке, после чего создается фиктивный объект и умный указатель переводится на него, чтобы программа могла хромать дальше.
79
Существует столько разных решений, сколько найдется программистов, достаточно глупых для попыток разыменования значения NULL. Вот лишь несколько из них.
Использование #indef
Если вас раздражают дополнительные вычисления, связанные с этой логикой, проще всего окружить if-блок директивами #ifdef, чтобы код обработки ошибок генерировался только в отладочных версиях программы. При компиляции рабочей версии перегруженный оператор -> снова сравнивается по быстродействию со встроенным указателем.
Инициирование исключений
Выдача сообщений об ошибках может вызвать проблемы в некоторых графических программах. Вместо этого можно инициировать исключение:
template <class Type> class Ptr {
private:
Type* pointer; public:
enum ErrorType { DereferenceNil };
Ptr() : pointer(NULL) {} Ptr(Type* p) : pointer(p) {}
operator Type*() { return pointer; } Type* operator->() throw(ErrorType)
{
if (pointer == NULL) throw DereferenceNil; return pointer;
}
};
(На практике ErrorType заменяется глобальным типом, используемым для различных видов ошибок; приведенный фрагмент лишь демонстрирует общий принцип.) Это решение может объединяться с другими. Например, программа может использовать фиктивный объект в отладочном варианте и инициировать исключение в рабочей версии.
Стукачи
Еще один вариант — хранить в статической переменной специальный объект, который я называю «стукачом» (screamer). Стукач ждет, пока кто-нибудь не попытается выполнить разыменование значения NULL.
template <class Type> class AHHH {
private:
Type* pointer;
static type* screamer; public:
AHHH() : pointer(NULL) {} AHHH(Type* p) : pointer(p) {}
Operator Type*() { return pointer; } Type* operator->()
{
if (p == NULL) return screamer; return pointer;
80
}
};
«Ну и что такого?» — спросите вы. Предположим, screamer на самом деле не принадлежит к типу Type* а относится к производному классу, все функции которого (предположительно виртуальные) выводят сообщения об ошибках в поток сеrr перед вызовом своих прототипов базового класса. Теперь вы не только удержите свою программу на плаву, но и сможете следить за попытками вызова функций фиктивного объекта.
Отладка и трассировка
Умные указатели также могут использоваться для наблюдения за объектами, на которые они указывают. Поскольку все обращения к объекту выполняются через операторную функцию operator Type*() или operator->(), у вас появляются две контрольные точки для наблюдения за происходящим во время работы программы. Возможности отладки безграничны, я приведу лишь один из примеров.
Установка точек прерывания
Самое простое применение упомянутых контрольных точек — сделать эти функции вынесенными (out- of-line) в отладочной версии и расставить точки прерывания в их реализации.
template <class Type> class PTracer { private:
Type* pointer; public:
PTracer() : pointer(NULL) {} PTracer(Type* p) : pointer(p) {} operator Type*();
Type* operator->();
};
template <class Type> #ifdef DEBUGGING inline
#endif
PTracer<Type>::operator Type*()
{
return pointer; |
// Здесь устанавливается точка прерывания |
}
template <class Type> #ifdef DEBUGGING inline
#endif
Type* PTracer<Type>::operator->()
{
return pointer; |
// Здесь устанавливается точка прерывания |
}
С непараметризованными версиями указателей это сделать несколько проще, поскольку не все среды разработки позволяют устанавливать точки прерывания в параметризованных функциях.
Трассировка
Оператор преобразования и оператор -> могут выводить диагностическую информацию в поток cout или cerr, в зависимости от ситуации.
81
Ведение статистики класса
Также несложно организовать накопление статистики об использовании операторов Type* и -> в статических переменных параметризованного класса.
template <class Type> class SPCS {
private:
Type* pointer;
static int conversions; static int members;
public:
SPCS() : pointer(NULL) {} SPCS(Type* p) : pointer(p) {}
operator Type*() { conversions++; return pointer; } Type* operator->() { members++; return pointer; } int Conversions() { return conversions; }
int Members() { return members; }
};
Глобальные переменные должны быть где-то определены. Обычно это делается в файле Foo.cpp:
// В файле Foo.cpp
int Ptr<Foo>::conversions = 0; int Ptr<Foo>::members = 0;
Разумеется, вы можете воспользоваться директивами #ifdef, чтобы это относилось только к отладочной версии.
Ведение статистики объекта
Мы подошли к более сложной теме. Возможно, ее следует отложить до знакомства с ведущими указателями (master pointers), однако умные указатели также могут вести статистику по отдельным объектам, а не по классу в целом. Задача не сводится к тому, чтобы сделать только что показанные переменные нестатическими (то есть по одному экземпляру переменных на указатель), поскольку мы (пока) не можем обеспечить однозначное соответствие между указателями и объектами. Вместо этого статистику придется хранить в самих объектах. Ниже приведен полезный вспомогательный класс, который можно создать на основе множественного наследования как производный от класса указываемого объекта и от класса умного указателя, знающего о его свойствах. Объявляя указатель другом, вы предоставляете ему доступ к защищенным членам классов, производных от Counter.
class Counter { protected:
Counter() : conversions(0), members(0) {} Counter(const Counter&) : conversions(0), members(0) {} Counter& operator=(const Counter&) { return *this; }
public:
int conversions; int members;
int Conversions() { return conversions; } int Members() { return members; }
};
template <class Type> class SPOP {
private:
Type* pointer;