Умные указатели

Забудьте все, что вам известно о С и примитивных операторах ->, и взгляните на проблему под новым углом. Рассмотрим следующий фрагмент:

class Foo { public:

void MemberOfFoo();

Foo* aFoo = new Foo; aFoo->MemberOfFoo();

Представьте, что встроенный оператор -> применяется к встроенному классу указателя - адресу, хранящемуся в aFoo. C++ предоставляет такой оператор для любого объекта, имеющего тип указателя на структуру, указателя на класс или указателя на объединение. Встроенные операторы -> осуществляют доступ к членам, указанным справа (в данном примере MemberOfFoo()). Фактически вы ссылаетесь на члена объекта (Foo) с помощью другого объекта и его оператора ->. То, что другой объект является указателем - всего лишь частный случай; вместо него мог бы использоваться ваш собственный класс с написанным вами нестандартным оператором ->.

Именно так следует подходить к оператору -> в C++, поскольку он, как и все остальные операторы (кроме оператора .), может перегружаться. Синтаксис был в общих чертах обрисован в главе 2, однако его последствия для программирования огромны, и их обсуждение займет эту и несколько следующих глав.

Глупые указатели

В C++ предусмотрено немало встроенных типов данных - например, int, double и указатели. Большинство этих встроенных типов удается относительно легко «упаковать» в разработанные вами классы. Например, если простой тип int недостаточно хорош для вас, можно создать совместимый класс Integer, который выглядит примерно так:

class Integer { private:

int value; public:

Integer() : va1ue(0) {}

Integer(int v) : value(v) {}

operator int() { return value; }

Integer operator+(Integer i) { return Integer(va1ue + i.value); } Integer operator+=(Integer i) { value += i.value; return *this; } И т.д. для остальных арифметических операторов

int f(int);

f(Integer(17)); Работает благодаря оператору int()

Конструкторы позволяют создавать экземпляры Integer из ничего, по существующему int или другому экземпляру Integer. Возможно, стоит создать дополнительные конструкторы для параметра char* (с преобразованием atoi()) и других числовых типов. Так как Integer иногда придется использовать вместо int (например, при вызове функции с аргументом int), мы предусмотрели оператор int() для выполнения автоматических преобразований. Скучная череда разных операторов воспроизводит всю семантику целочисленной арифметики. Ура! Отныне вместо int можно повсюду использовать Integer. Мы создали новый класс, который полностью заменяет примитивный int. Выпейте чашку кофе.

Уже вернулись? Предположим, в своем стремлении к абстрактным типам данных в C++ (политически правильный термин для классов-оболочек) вы решили, что *-указатели вас уже не устраивают, и вы хотите спрятать их в своих классах (не спрашивайте почему; я же сказал, что это была ваша идея!). Давайте проделаем мысленный эксперимент и посмотрим, что для этого нужно. Итак, первая попытка.

class PFoo { private:

Foo* foo; public:

PFoo() : foo(NULL) {} PFoo(Foo* f) : foo(f) {} operator Foo*() { return foo; }

PFoo operator+(ptr diff offset) { return PFoo(foo + offset); } PFoo operator+=(ptr diff offset) { foo += offset; return *this; } ptr diff operator-(PFoo pf) { return foo - pf.foo; } И т.д. для всех остальных арифметических операций с указателями

Ура! У вас появился новый класс, совместимый с Foo*! С арифметическими операторами дело обстоит несколько сложнее. Например, вам наверняка пришлось докопаться в справочнике, чтобы узнать, что ptr diff является переносимым способом описания разности между двумя адресами памяти. Все это выглядит занудно, поскольку класс ориентирован на Foo, но зато теперь вы можете всюду использовать PFoo вместо Foo*... Но так ли это? Подождите минутку и оставьте вторую чашку кофе. Наш вариант не работает.

PFoo pf(new Foo*);

pf->MemberOfFoo(); Неверно

((Foo*)pf)->MemberOfFoo(); Работает, но выглядит ОМЕРЗИТЕЛЬНО!

Оператор Foo*() позволит передавать PFoo в качестве аргумента функциям, которые должны получать Foo*. Также воспроизводятся все арифметические операции с указателями, но часть семантики все же теряется, поскольку оператор -> не работает в прежнем виде. Я называю такие указатели «глупыми», так как они очень наивны и ведут себя совсем не так, как должны себя вести настоящие указатели.

Итак, почему написать оболочку для указателей сложнее, чем для других базовых типов?

1 . Компилятор создает отдельный тип указателя для каждого типа структуры, класса или объединения. Чтобы создать оболочки для всех указателей, вам придется думать, как сделать это для всех возможных типов указателей. Описанный выше класс PFoo работает лишь для класса Foo и производных от него.

2. Приходится учитывать и другие, взаимосвязанные типы данных (например, size t и ptr diff). Если мы хотим полностью «упаковать» указатели в наш класс, придется создавать эквиваленты и для этих типов.

3. Вся суть встроенных указателей - обращение к членам объекта с использованием оператора ->. Для воспроизведения этой семантики оператора преобразования оказывается недостаточно.

Умные указатели как идиома

Возникающие проблемы стоит разбирать последовательно. До арифметических операций с указателями мы доберемся позже, поэтому пока будем пользоваться ptr diff.

Оператор ->

Теперь вы знаете, почему оператор -> был сделан перегружаемым. В полном соответствии с синтаксисом, описанным в главе 2, PFoo теперь обзаводится собственным оператором ->. Оператора преобразования хватает для вызова внешних функций. Приведенный ниже вызов функции f() работает, потому что у компилятора хватает ума поискать оператор преобразования, соответствующий сигнатуре функции, и в данном случае оператор Foo*() прекрасно подходит.

class PFoo { private:

Foo* foo; public:

PFoo() : foo(NULL) {}

PFoo(Foo* f) : foo(f) {}

operator Foo*() { return foo; }

Foo* operator->() { return foo; }

void f(Foo*); PFoo pf(new Foo);

f(pf); Работает благодаря функции operator Foo*()

pf->MemberOfFoo(); Работает благодаря функции operator->()

Причина, по которой работает pf->MemberOfFoo(), менее очевидна. В левой части оператора -> указан пользовательский тип, поэтому компилятор ищет перегруженную версию оператора ->. Он находит ее, вычисляет и заменяет pf возвращаемым значением, которое превращается в новое левостороннее выражение оператора ->. Этот процесс рекурсивно продолжается до тех пор, пока левостороннее выражение не преобразуется к базовому типу. Если таким базовым типом является указатель на структуру, указатель на класс или указатель на объединение, компилятор обращается к указанному члену. Если это что-то иное (например, int), компилятор злорадно хохочет и выдает сообщение об ошибке. В нем он оценивает ваш интеллект и перспективы будущей работы на основании того факта, что вы пытаетесь обратиться к члену чего-то, вообще не имеющего членов. В любом случае поиск заканчивается при достижении базового типа. Для самых любопытных сообщаю, что большинство компиляторов, которыми я пользовался, не отслеживает истинной рекурсии вида:

PFoo operator->() { return *this; }

Здесь оператор -> пользовательского типа возвращает экземпляр этого типа в качестве своего значения. Компиляторы C++ обычно предпочитают помучить вас в бесконечном цикле.

Итак, у нас появился класс-указатель, который можно использовать везде, где используются указатели Foo*: в качестве аргументов функций, слева от оператора -> или при определении дополнительной семантики арифметических операций с указателями - всюду, где Foo* участвует в сложении или вычитании.

Параметризованные умные указатели

Один из очевидных подходов к созданию универсальных умных указателей - использование шаблонов.

template <c1ass Type> class SP { private:

Type* pointer; public: