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

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

class Integer {

private:

int value;

public:

Integer() : value(0) {}

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

operator int() { return value; }

Integer operator+(Integer i) { return Integer(value + 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. Вся суть встроенных указателей - обращение к членам объекта с использованием оператора ->. Для воспроизведения этой семантики оператора преобразования оказывается недостаточно.