Постановка задачи.

        Перед нами ставится следующая задача: создать шаблон, назовём его smart_ptr, с реализацией некоторых функций шаблона auto_ptr стандартной библиотеки C++ для автоматического удаления динамически созданных объектов при выходе из области видимости указателей (возможно нескольких) на них. Другими словами, допустим, у нас есть n динамически созданных (при помощи new) объектов одного типа, и имеется m указателей на них, при этом m>=n. Необходимо создать такой шаблон, который позволил бы реализовать автоматическое удаление объекта из памяти после удаления последнего указателя на него. Графически исходные данные можно представить следующим образом:

Предлагаемое решение

        Предлагаемое решение не является единственным решением поставленной задачи. Кроме того, я не утверждаю, что предложенное решение является наилучшим, но, на мой взгляд, является более-менее логичным. Итак, что же за решение я предлагаю: создадим шаблон (в терминах C++) smart_ptr, содержащий внутри себя (в секции private) статический список (std::list), содержащий пары (std::pair), первый член которых – указатель на объект, а второй член – количество указателей на объект, которые были переданы шаблону smart_ptr.
 Создадим каркас класса шаблона smart_ptr:

template<class T> class smart_ptr { /**/ };

Для дальнейшей простоты написания (и восприятия, кстати, тоже) сделаем пару forward-объявлений:

• Определим std::pair<int ,T*> как pair_type:

typedef typename std::pair<int ,T*> pair_type;

• Определим std::list<pair_type> как ptr_list:

typedef typename std::list<pair_type> ptr_list;

Определим статический список ptr_list пар типа pair_type:

static ptr_list ptrs;

Кроме того, нам потребуется отдельно хранить указатель на объект в каждом конкретном экземпляре класса smart_ptr:

T *ptr;

Теперь private-секция класса будет выглядеть так:

template<class T> class smart_ptr
{
private:
    typedef typename std::pair<int ,T*>   pair_type;
   typedef typename std::list<pair_type> ptr_list;
static ptr_list ptrs;
    T *ptr;
/**/
}

Примечание: Хочу обратить Ваше внимание на наличие ключевого слова typename после typedef. Раньше стандарт C++ позволял не писать это ключевое слово, поэтому его можно не писать в «старых» компиляторах: например, Microsoft Visual C++.NET 2002 такое пропустит, а вот 2003 уже нет… Кому интересно для чего это нужно – читайте стандарт C++…

Реализация

        Итак, мы подошли к самому интересному разделу: реализации решения задачи. Зачастую, далеко не достаточно просто найти решение задачи, потому что решение может быть не реализуемым средствами языка. Наша задача – куда проще, поэтому и реализовать её достаточно просто, однако и тут есть свои «подводные камни».
        Всё решение будет в основном лежать в конструкторе и деструкторе объекта, однако, нам понадобится дополнительный интерфейс для доступа к хранимому объекту, а также манипуляции с ним.
        Конструкторы и деструктор, которые нам понадобятся:
• Конструктор по-умолчанию. В принципе, такой можно и не создавать, т. к. у объекта есть конкретная задача – хранение указателя на объект. В данном случае указатель инициализируется значением NULL.

smart_ptr(void);

• Конструктор с инициализацией хранимого указателя. Этот конструктор и будет «рабочей лошадкой».

smart_ptr(T*);

• Конструктор копий. Его необходимо реализовать по той причине, что нет смысла хранить один и тот же указатель в двух разных объектах smart_ptr. Кого интересует больше – почитайте про auto_ptr – тот же самый принцип. Обратите внимание, мы не гарантируем константности исходного объекта: ключевого слова const, как принято в конструкторах копий, нет:

smart_ptr(smart_ptr<T>&);

• Деструктор. Ну тут всё просто:

~smart_ptr(void);

        Помимо конструкторов и деструктора, как уже говорилось ранее, нам понадобится интерфейс доступа к объекту. Минимально-оптимальный набор будет следующим:

• Переустановка/сброс хранимого указателя:

void reset(T *_ptr = NULL) throw();

• Получение хранимого указателя:

T* get(void) throw ();

• Освобождение экземпляра от обязанностей:

T* release(void) throw ();

• Получить количество хранимых указателей на данный объект:

int counter(void) const throw ();

Примечание: Здесь и далее, я указываю на то, что мои методы ни при каких условиях не генерируют исключений. Это задаётся спецификацией исключения, ключевым словом throw() после объявления метода. Напоминаю, что если Ваш метод не меняет внутреннего состояния класса, используйте модификатор const после объявления функции. Помните, что это вовсе не для украшения: Ваш интерфейс могут использовать другие люди, которым нужны гарантии…

        И, конечно же, операторы:

• Оператор разыменовывания:

T& operator*() const throw ();

• Оператор доступа к членам объекта:

T* operator->() const throw ();

• Оператор присваивания:

smart_ptr<T> operator=(smart_ptr<T>&) throw();

• Оператор неравенства:

bool operator!=(smart_ptr<T> const&) const throw();

• Оператор равенства:

bool operator!=(smart_ptr<T> const&) const throw();

Примечание: Создавая новый класс, помните об операторах. Они нужны людям так же, как и гарантии…

        Итак, мы получили полное объявление класса:

template<class T> class smart_ptr
{
private:
    typedef typename std::pair<int,T*>    pair_type;
    typedef typename std::list<pair_type> ptr_list;
      static ptr_list ptrs;
                  T *ptr;
public:
      smart_ptr(void );
      smart_ptr(T*);
      smart_ptr(smart_ptr<T>&);
     ~smart_ptr(void );
public:
      void reset(T *_ptr = NULL) throw ();
      T*   get(void)             throw ();
      T*   release(void)         throw ();
      int  counter(void)  const  throw ();
public:
     T&            operator * () const throw ();
     T*            operator ->() const throw ();
     smart_ptr<T>  operator=  (smart_ptr<T>&      )       throw ();
     bool          operator!= (smart_ptr<T> const&) const throw ();
     bool          operator== (smart_ptr<T> const&) const throw ();
};

        Все статические элементы необходимо инициализировать вне объявления класса:

template<class T> typename smart_ptr<T>::ptr_list smart_ptr<T>::ptrs = smart_ptr<T>::ptr_list();