Просмотр исходного текста страницы Умные указатели C++

== Введение ==
Умные указатели (УА) ([http://en.wikipedia.org/wiki/Smart_pointers smart pointers])
используюу принцип "''[http://ru.wikipedia.org/wiki/%D0%9F%D0%BE%D0%BB%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5_%D1%80%D0%B5%D1%81%D1%83%D1%80%D1%81%D0%B0_%D0%B5%D1%81%D1%82%D1%8C_%D0%B8%D0%BD%D0%B8%D1%86%D0%B8%D0%B0%D0%BB%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F Получение ресурса есть инициализация]''" ([http://en.wikipedia.org/wiki/RAII RAII]) для автоматизации управления памятью.
Использование правильного умного указателя упростит и обезопасит ваш код, а так же поможет избежать memory leak-ов.

=== Виды умных указателей ===
Умные указатели можно разделить на три вида:
* с безраздельным владением:
** std::auto_ptr
** boost::scoped_ptr
** boost::scoped_array

* с раздельным владением:
** boost::shared_ptr
** boost::shared_array
** boost::intrusive_ptr

== Умные указатели с безраздельным владением ==
Умные указатели этого вида предназначены для хранения на стэке или для включения в класс.

Особняком в этом классе держится std::auto_ptr. С него и начнем.

=== std::auto_ptr ===
std::auto_ptr спроектирован для того, чтобы сделать код безопасным с точки зрения исключений.
Использование std::auto_ptr позволяет писать код, который отвечает строгой гарантии относительно
исключений ([http://en.wikipedia.org/wiki/Exception_handling strong exception guarantee]). Подробное
описание того, как с помощью std::auto_ptr сделать Ваш код безопасным нужно читать в книге Герба Саттера
[http://www.books.ru/shop/books/30998 "Решение сложных задач на C++"] (вторая глава).

Основное отличие std::auto_ptr от умных указателей с безраздельным владением заключается в наличии у него
конструктора копирования, оператора присваивания и метода release.
При копировании (как и при присваивании) std::auto_ptr передает владение объектом, а метод release()
позволяет явно отобрать владение объектом у std::auto_ptr.
<source lang="cpp">
std::auto_ptr<A> p1, p2;
p1.reset( new A() ); // p1 владеет A, p2 == NULL
p2 = p1; // p1 передает владение p2. Теперь p1 == NULL, а p2 владеет A
std::auto_ptr<A> p3(p2); // p2 передает владение p3
A * p4 = p3.release(); // p3 передает владение p4
</source>

Такое поведение позволяет безопасно передавать в функцию и возвращать из функции объекты, которые могут бросать
исключения при копировании, а также избегать ликов.
<source lang="cpp">
std::auto_ptr<A> foo(int a)
{
return std::auto_ptr<A>(new A(a));
}

void bar(std::auto_ptr<A> pa)
{
throw 1;
}

int main()
{
std::auto_ptr<A> pa;
pa = foo(10); // Здесь все ок - ликов нет
foo(20); // Здесь тоже все ок, не смотря на то, что возвращаемое значение проигнорировано
bar(pa); // И здесь все тоже будет хорошо
}
</source>

Все это делает std::auto_ptr ''особенным объектом'', которые не имеет семантики значения.
Именно по этому '''его нельзя использовать в контейнерах''' (да и не получится =) ).

==== Особенности ====
* его нельзя использовать в контейнерах
* если std::auto_ptr - член класса, то обязятельно '''переопределите конструктор копирования и оператор присваивания или явно запретите их''' (к примеру, при помощи boost::noncopyable)
* std::auto_ptr не имеет аналогов в boost-е
* в VS 8.0 реализация std::auto_ptr содержит ошибку.
<source lang="cpp">
std::auto_ptr<int > p;
p = new int(5); // в этом месте программа упадет.
// В VS7 такой код не скомпилируется, т.к. отсутствует operator=(T *)
</source>
идиома "const std::auto_ptr" - простой способ получить аналог boost::scoped_ptr. const гарантирует, что не произойдет передачи владения.
<source lang="cpp">
std::auto_ptr<T> create_new_T();

int main()
{
std::auto_ptr<T> const p = create_new_T();
std::auto_ptr<T> q = p; // это не скомпилируется, благодаря const
return 0;
}
</source>

=== boost::scoped_ptr ===
Классический умный указатель с безраздельным владением.

==== Особенности ====
* его нельзя использовать в контейнерах
* нет метода release
* нет конструктора копирования и оператора присваивания

=== boost::scoped_array ===
Аналог boost::scoped_ptr для массивов. Отличается от boost::scoped_ptr тем, что
удаляет хранимый указатель при помощи '''delete[]'''.

==== Особенности ====
* его нельзя использовать в контейнерах
* нет метода release
* вызывает '''delete[]''' для хранимого указателя

== Умные указатели с раздельным владением ==
Умные указатели с раздельным владением предназначены для того, что бы разделять один объект
между несколькими клиентами. Основное отличие указателей этого типа заключается в стратегии
подсчета ссылок.

=== boost::shared_ptr ===
Самый мощный и умный указатель. Использует счетчик ссылок в динамической памяти.

==== Особенности ====
* можно и нужно использовать в контейнерах
* сохраняет ссылку на функцию delete того модуля, в котором объект был выделен.
(boost::shared_ptr можно спокойно передать между модулями с разным рантаймом)
* счетчик ссылок защищен для работы в разных потоках
(это можно отключить при помощи '''#define BOOST_SP_DISABLE_THREADS''')
* позволяет хранить указатели разных типов на один объект
<source lang="cpp">
struct A {};
struct B : A {};

boost::shared_ptr<B> pb (new B());
boost::shared_ptr<A> pa (static_pointer_cast(pb));
boost::shared_ptr<B> pb2 (dynamic_pointer_cast(pa));
boost::shared_ptr<const B> pb3 (const_pointer_cast(pa));
</source>

=== boost::shared_array ===
Аналог boost::shared_ptr для хранения массивов объектов.

=== boost::intrusive_ptr ===
Данный умный указатель требует существования двух функций '''intrusive_ptr_add_ref''' и '''intrusive_ptr_add_release''',
при помощи которых происходит подсчет ссылок. Обычно это означает, что счетчик хранится в самом объекте.

==== Особенности ====
* можно и нужно использовать в контейнерах
* требует определения функций '''intrusive_ptr_add_ref''' и '''intrusive_ptr_add_release'''.
* можно спокойно передать в функцию "чистый" указатель, полученный через '''get()''', а внутри функции снова обернуть его в boost::intrusive_ptr (как часто делается с _com_ptr_t)
* не существует аналогичного указателя для хранения массивов
* имеет operator=(T*)

== Умные указатели и boost::bind ==
Для того, что бы умные указатели работали с boost::bind требуется определить для них функцию
<source lang="cpp">
T * get_pointer( pointer<T> const& p );
</source>
Для большинства умных указателей, которые можно хранить в STL-ных контейнерах,
эта функция уже определена. 
Для того, что бы заставить работать boost::bind с вашим умным указателем добавить следующий код
<source lang="cpp">
#define BOOST_MEM_FN_ENABLE_STDCALL
#include <boost/bind.hpp>

//....

template< class T >
T * get_pointer( MySmartPtr< T > const& p ) { return p.get(); }
</source>