smart-pointers.tex

\section{Умные указатели}

Рассмотрим следующий код:

\begin{minted}[
linenos,
frame=lines,
framesep=2mm]
{c++}
container* create_container()
{
    container* c = new container();
    fill(*c);
    return c;
}
\end{minted}

В приведенном коде, при возникновении исключения в функции fill, это исключение пролетит наружу функции create\_container. Однако выделенный с помощью new контейнер c не будет освобожден. Возможным способом исправления этой ошибки является использование try…catch блока:

\begin{minted}[
linenos,
frame=lines,
framesep=2mm]
{c++}
container* create_container()
{
    container* c = new container();
    try
    {
        fill(*c);
    }
    catch(...)
    {
        delete c;
        throw;
    }
    return c;
}
\end{minted}

Такой способ применим если лишь к простейшим функциям. При начилии нескольких объектов, которые требуется удалить или в присутствии сложного control-flow такое использование try...catch становится непрактичным.

Для решения этой проблемы в C++11 появились классы умных указателей (\mintinline{c++}{std::unique_ptr}, \mintinline{c++}{std::shared_ptr} и \mintinline{c++}{std::weak_ptr}). Эти классы являются RAII-обертками над обычными указателями, которые в своём деструкторе делают \mintinline{c++}{delete} тому объекту, на который они ссылаются. При использовании \mintinline{c++}{std::unique_ptr} приведенный выше (корректный) код может быть записан следующим образом:

\begin{minted}[
linenos,
frame=lines,
framesep=2mm]
{c++}
std::unique_ptr<container> create_container()
{
    std::unique_ptr<container> c(new container());
    fill(*c);
    return c;
}
\end{minted}

\subsection{\mintinline{c++}{std::unique_ptr}}
Самым простым умным указателем является \mintinline{c++}{std::unique_ptr}.
Внутри себя \mintinline{c++}{std::unique_ptr} хранит один указатель \mintinline{c++}{T* ptr} и делает ему \mintinline{c++}{delete} в дескрукторе.

\begin{minted}[
linenos,
frame=lines,
framesep=2mm]
{c++}
template<class T>
class unique_ptr
{
private:
    T* ptr;
public:
    unique_ptr()
        : ptr(nullptr)
    {}

    unique_ptr(T* ptr)
        : ptr(ptr)
    {}

    ~unique_ptr()
    {
        delete ptr;
    }
    ...
}
\end{minted}

\mintinline{c++}{std::unique_ptr} имеет операторы \mintinline{c++}{*} и \mintinline{c++}{->}, поэтому им можно пользоваться как обычным указателем:

\begin{minted}[
linenos,
frame=lines,
framesep=2mm]
{c++}
T& operator*() const { return *ptr; }
T* operator->() const noexcept { return ptr; }
\end{minted}

\mintinline{c++}{std::unique_ptr} имеет следующие функции:

\mintinline{c++}{get()} --- возвращает ptr, хранящийся внутри. \mintinline{c++}{get()} может использоваться если необходимо передать в некоторую функцию сырой указатель на объект, а имеется \mintinline{c++}{unique_ptr} на него.

\begin{minted}[
linenos,
frame=lines,
framesep=2mm]
{c++}
T* get() const { return ptr; }
\end{minted}

\mintinline{c++}{release()} --- зануляет ptr, хранящийся внутри, а старое значение возвращает наружу. \mintinline{c++}{release()} может использоваться если необходимо передать в некоторую функцию сырой указатель на объект и известно, что эта функция самостоятельно удалит переданный объект.

\begin{minted}[
linenos,
frame=lines,
framesep=2mm]
{c++}
T* release()
{
    T* tmp = ptr;
    ptr = nullptr;
    return tmp;
}
\end{minted}

\mintinline{c++}{reset(p)} - заменяет ptr, хранящийся внутри, на p, и делает \mintinline{c++}{delete} старому ptr.
\begin{minted}[
linenos,
frame=lines,
framesep=2mm]
{c++}
void reset(T* p)
{
    delete ptr;
    ptr = p;
}
\end{minted}

Оператор присваивания и конструктор копирования у \mintinline{c++}{unique_ptr} явно запрещены:
\begin{minted}[
linenos,
frame=lines,
framesep=2mm]
{c++}
unique_ptr(unique_ptr& other) = delete;
unique_ptr& operator=(unique_ptr& other) = delete;
\end{minted}
При попытке скопировать или присвоить \mintinline{c++}{unique_ptr} выдаётся ошибка на этапе компиляции.

\mintinline{c++}{unique_ptr} имеет move-оператор присваивания и move-конструктор, которые зануляют указатель, стоящий справо:

\begin{minted}[
linenos,
frame=lines,
framesep=2mm]
{c++}
unique_ptr& operator=(unique_ptr&& other) noexcept
{
    reset(other.release());
    return *this;
}

unique_ptr(unique_ptr&& other) noexcept
    : ptr(other.release())
{}
\end{minted}

\subsubsection{Неявные приведения}
\label{unique_ptr_implicit_conversions}

Обычные указатели можно неявно приводить. Например если \mintinline{c++}{B} является некоторым классом, а \mintinline{c++}{D} является производным от него, то разрешено неявное приведение \mintinline{c++}{D*} в \mintinline{c++}{B*}. \mintinline{c++}{unique_ptr} поддерживает аналогичное приведение. \mintinline{c++}{unique_ptr} использует SFINAE-проверку, чтобы разрешить приведение \mintinline{c++}{unique_ptr<D>} в \mintinline{c++}{unique_ptr<B>} тогда и только тогда, когда разрешено приведение \mintinline{c++}{D*} в \mintinline{c++}{B*}.

\begin{minted}[
linenos,
frame=lines,
framesep=2mm]
{c++}
template <typename T>
struct unique_ptr
{
    template <typename U,
              typename = typename std::enable_if_t<is_convertible_v<U*, T*>>>
    unique_ptr(unique_ptr<U>&& other);
};
\end{minted}

\subsubsection{Настраиваемый deleter}

В некоторых случаях для освобождения памяти необходимо использовать не \mintinline{c++}{delete}, а другие операции. Например если память была выделена с помощью функции \mintinline{c++}{malloc} её следует освобождать функцией \mintinline{c++}{free}, а если с помощью оператора \mintinline{c++}{new[]} для массивов, то оператором \mintinline{c++}{delete[]} для массивов. Существуют и другие способы освобождения ресурсов, поэтому в некоторых случаях может потребоваться исполнение какого-то произвольного кода в деструкторе \mintinline{c++}{unique_ptr}. \mintinline{c++}{unique_ptr} поддерживает такое использование.

Для того, чтобы указать, что именно делать в деструкторе, \mintinline{c++}{std::unique_ptr} получает специальный объект называемый {\bf deleter}. Сильно упрощенно \mintinline{c++}{unique_ptr} с deleter'ом можно записать следующим образом:
\begin{listing}
\begin{minted}[
linenos,
frame=lines,
framesep=2mm]
{c++}
template <typename T, typename D = default_delete<T>>
struct unique_ptr
{
    using pointer = typename D::pointer;

    unique_ptr(pointer);
    unique_ptr(pointer, D);

    ~unique_ptr()
    {
        deleter(ptr);
    }

private:
    pointer ptr;
    D deleter;
};
\end{minted}
\caption{Упрощенная реализация \mintinline{c++}{unique_ptr} с deleter'ом}
\label{listing:unique_ptr_with_deleter}
\end{listing}

Таким образом видно, что на самом деле \mintinline{c++}{unique_ptr} хранит в качестве указателя не обязательно \mintinline{c++}{T*}, а любой объект типа \mintinline{c++}{D::pointer}. По этой причине некоторые члены \mintinline{c++}{unique_ptr} не помечены \mintinline{c++}{noexcept}, например, \mintinline{c++}{operator*}.

По умолчанию в качестве deleter используется класс \mintinline{c++}{default_delete}, который вызывает оператор \mintinline{c++}{delete} на переданном указателе.

В реальности \mintinline{c++}{std::unique_ptr} устроен гораздо сложнее, чем показано на листинге \ref{listing:unique_ptr_with_deleter}. Это обусловлено следующими причинами:

\begin{itemize}
    \item Шаблонный параметр \mintinline{c++}{D} может быть не самим типом deleter'а, а ссылой на deleter. Поэтому при обращении \mintinline{c++}{D::pointer}, предварительно следует снять ссылку с \mintinline{c++}{D}.
    \item Deleter не обязан содержать typedef \mintinline{c++}{pointer}. Если он отсутствует, \mintinline{c++}{unique_ptr} должен использовать \mintinline{c++}{T*} вместо него. Это требует от \mintinline{c++}{unique_ptr} использования SFINAE-проверки.
    \item Часто deleter является пустым объектом. Чтобы не увеличивать размер \mintinline{c++}{unique_ptr} при реализации используется empty-base оптимизация.
\end{itemize}

При перемещении \mintinline{c++}{unique_ptr}, перемещается и его deleter. Отдельно следует рассмотреть, что происходит с deleter'ами при неявных приведениях \mintinline{c++}{unique_ptr} рассмотренных в разделе \ref{unique_ptr_implicit_conversions}. Важным является тот факт, что результирующий \mintinline{c++}{unique_ptr} и исходный могут иметь deleter'ы разных типов. При использовании deleter'ов, конверсия из \mintinline{c++}{unique_ptr<T1, D1>} разрешена в \mintinline{c++}{unique_ptr<T2, D2>} если выполнено одно из двух условий:
\begin{itemize}
    \item \mintinline{c++}{D2} является ссылкой и \mintinline{c++}{D1} совпадает с \mintinline{c++}{D2}.
    \item \mintinline{c++}{D2} не является ссылкой и \mintinline{c++}{D1} приводим в \mintinline{c++}{D2}.
\end{itemize}

\subsubsection{unique\_ptr для массивов}

\mintinline{c++}{unique_ptr} имеет отдельную специализацию для массивов:

\begin{minted}[
linenos,
frame=lines,
framesep=2mm]
{c++}
template <typename T, typename D = default_delete<T>>
struct unique_ptr;

template <typename E, typename D>
struct unique_ptr<E[], D>
{
    E& operator[](size_t index) const;
};
\end{minted}

\mintinline{c++}{unique_ptr} для массивов отличается от обычного \mintinline{c++}{unique_ptr} следующими свойствами:
\begin{itemize}
    \item \mintinline{c++}{unique_ptr} для массивов имеет \mintinline{c++}{operator[]}. Обычный \mintinline{c++}{unique_ptr} не имеет \mintinline{c++}{operator[]}.
    \item \mintinline{c++}{unique_ptr} для массивов хранит внутри себя \mintinline{c++}{E*}, а не \mintinline{c++}{T*}.
    \item \mintinline{c++}{unique_ptr} для массивов использует более жесткие правила для неявных преобразований. Обычные указатели можно приводить по иерархии наследования. Но указатель на массив элементов типа \mintinline{c++}{D} не приводим в указатель на массив элементов типа \mintinline{c++}{B}, даже если \mintinline{c++}{D} --- это тип производный от \mintinline{c++}{B}, поскольку \mintinline{c++}{B} и \mintinline{c++}{D} могут иметь разных размер, а в массиве элементы расположены подряд.
\end{itemize}

Как и \mintinline{c++}{unique_ptr}, \mintinline{c++}{default_delete} имеет специализацию для массивов, которая делает \mintinline{c++}{delete[]} вместо обычного \mintinline{c++}{delete}.

\subsection{Владение}
Ответственность за удаление объекта называется владением. Например, unique\_ptr ответственен за удаление объекта на который он ссылается, соответственно говорят, что unique\_ptr владеет объектом, на который он ссылается. Про функцию \mintinline{c++}{reset(p)} говорят, что она передает владение объектом unique\_ptr'у, а функция \mintinline{c++}{release()}, наоборот, забирает владение объектом у unique\_ptr'а.

Термин владение применяется не только к умным указателям, например можно сказать, что std::vector владеет памятью выделенной под свои элементы (обязан её освободить), а также владеет своими элементами (обязан вызывать им деструктор).

В некоторых случаях объект может иметь несколько владельцев. Это называется разделяемым владением и работает следующим образом: пока существует хотя бы один владелец объект продолжает жить, когда пропадает последний владелец --- объект удаляется. Для умных указателей существует два способа реализации разделяемого владения: подсчет ссылок и провязка всех владельцев в двусвязный список. Оба подхода имеют свои преимущества и недостатки. Подсчет ссылок применяется во включенном в стандартную библиотеку указателе std::shared\_ptr. Указатель использующий провязку владельцев в двусвязный список в стандартной библиотеке отсутствует, но часто называется linked\_ptr.

\subsection{\mintinline{c++}{std::shared_ptr}}
\mintinline{c++}{std::shared_ptr} --- это умный указатель, с разделяемым владением. \mintinline{c++}{std::shared_ptr} умеет создаваться от обычного указателя и копироваться.

\begin{minted}[
linenos,
frame=lines,
framesep=2mm]
{c++}
template<class T>
class shared_ptr
{
    // создаёт shared_ptr не ссылающийся ни на один объект
    shared_ptr();
    // создаёт shared_ptr ссылающийся на *ptr либо, если ptr == nullptr, не ссылающийся ни на один объект
    explicit shared_ptr(T* ptr);
    // создает shared_ptr ссылающийся на тот же объект, что и other
    shared_ptr(shared_ptr const& other);
    // изменяет shared_ptr так, чтобы он ссылался на тот же объект, что и rhs
    shared_ptr& operator=(shared_ptr const& rhs);
};
\end{minted}

Несколько \mintinline{c++}{shared_ptr}'ов могут ссылаться на один объект. Объект, однажды обернутый в \mintinline{c++}{shared_ptr}, будет удален в тот момент, когда не останется \mintinline{c++}{shared_ptr}'ов ссылающихся на него.

Как и \mintinline{c++}{unique_ptr} \mintinline{c++}{shared_ptr} поддерживает операции \mintinline{c++}{operator*}, \mintinline{c++}{operator->}, \mintinline{c++}{reset}, \mintinline{c++}{get} с той же семантикой, что и у \mintinline{c++}{unique_ptr}. Операция \mintinline{c++}{release} отсутствует для \mintinline{c++}{shared_ptr}'а поскольку в общем случае она не возможна, из-за того, что могут существовать другие \mintinline{c++}{shared_ptr}'ы ссылающиеся на этот же объект.

\subsubsection{Наивная реализация}

При наивной реализации \mintinline{c++}{shared_ptr} мог бы хранить указатель на ссылаемый объект и счетчик ссылок. Поскольку значение счетчика ссылок является общим между всеми \mintinline{c++}{shared_ptr} ссылающимися на данный объект, \mintinline{c++}{shared_ptr} вынужден хранить указатель на счетчик ссылок и аллоцировать память под счетчик ссылок динамически.

\begin{minted}[linenos, frame=lines, framesep=2mm, tabsize = 4, breaklines]{c++}
template <typename T>
struct shared_ptr
{
    // ...

private:
    // Класс имеет следующий инвариант:
    // Если shared_ptr не ссылается ни на один объект, и ptr и ref_counter равны nullptr.
    // Если shared_ptr ссылается на некоторый объект, и ptr и ref_counter не равны nullptr.
    // *ref_counter равен числу shared_ptr'ов ссылающихся на объект *ptr.
    T* ptr;
    size_t* ref_counter;
};

template <typename T>
shared_ptr<T>::shared_ptr()
    : ptr(nullptr)
    , ref_counter(nullptr)
{}

template <typename T>
shared_ptr<T>::shared_ptr(T* ptr)
    : ptr(ptr)
{
    if (!ptr)
        return;

    try
    {
        ref_counter = new size_t(1);
    }
    catch (...)
    {
        delete ptr;
        throw;
    }
}

template <typename T>
shared_ptr<T>::shared_ptr(shared_ptr const& other)
    : ptr(other.ptr)
    , ref_counter(other.ref_counter)
{
    if (!ptr)
        return;

    ++*ref_counter;
}

template <typename T>
shared_ptr<T>::~shared_ptr()
{
    if (!ptr)
        return;

    if (--*ref_counter == 0)
    {
        delete ref_counter;
        delete ptr;
    }
}
\end{minted}

Нетривиальным моментом в реализации является конструктор \mintinline{c++}{shared_ptr(T* ptr)} и блок \mintinline{c++}{try...catch} внутри него. На первый взгляд может показаться, что этот блок не требуется и даже мешает, поскольку из-за него конструктор перестает удовлетворять строгой гарантии безопасности исключений. Однако существует веский аргумент в пользу такой релизации. Рассмотрим следующее использование \mintinline{c++}{shared_ptr}:

\begin{listing}
\begin{minted}[linenos, frame=lines, framesep=2mm, tabsize = 4, breaklines]{c++}
shared_ptr<T> p(new T());
\end{minted}
\caption{Типичное создание \mintinline{c++}{shared_ptr}}
\label{listing:shared_ptr_attach_to_object}
\end{listing}

Если конструктор \mintinline{c++}{shared_ptr} при ошибке аллокации счетчика ссылок не будет удалять переданный указатель, то этот указатель нигде не будет удалён и любой код аналогичный листингу \ref{listing:shared_ptr_attach_to_object} был бы ошибочным. Поэтому конструктор \mintinline{c++}{shared_ptr} от указателя удаляет объект, если происходит ошибка аллокации счетчика ссылок. Можно сказать что конструктор \mintinline{c++}{shared_ptr} забирает владение указателем даже если он бросает исключение.

\subsubsection{Проблема разделения счетчика ссылок}
\label{reference_counter_split_problem}

Расмотрим следующий код:
\begin{minted}[linenos, frame=lines, framesep=2mm, tabsize = 4, breaklines]{c++}
T* p = new T();
std::shared_ptr<T> p1(p);
std::shared_ptr<T> p2(p);
\end{minted}
Данный код содержит ошибку. Каждый из вызовов \mintinline{c++}{shared_ptr(T*)} создаст свой собственный счетчик ссылок. В результате получится один объект и два счетчика ссылок к нему. Объект удалится, когда хотя бы один из счетчиков ссылок достигнет нуля. Когда второй из счетчиков достигнет нуля произойдет ошибка повторного удаления. Описанная ситуация называется разделением ({\it split}) счетчика ссылок. Разделение счетчика ссылок является ошибкой и не должно возникать в корректных программах.

Чтобы не происходило разделение счетчика ссылок нужно не оборачивать один сырой указатель в \mintinline{c++}{shared_ptr} дважды. Использование \mintinline{c++}{std::make_shared} (раздел \ref{make_shared}), либо использование \mintinline{c++}{std::enable_shared_from_this} (раздел \ref{enable_shared_from_this}) также позволяет избежать разделения счетчика ссылок.

\subsubsection{Настраиваемый deleter}
\label{shared_ptr_custom_deleter}

Аналогично \mintinline{c++}{unique_ptr} \mintinline{c++}{shared_ptr} позволяет настроить как именно удалять объект, когда не осталось \mintinline{c++}{shared_ptr}'ов ссылающихся на него. В отличие от \mintinline{c++}{unique_ptr} тип \mintinline{c++}{shared_ptr} не зависит от типа deleter'а.

\begin{minted}[linenos, frame=lines, framesep=2mm, tabsize = 4, breaklines]{c++}
template <typename T>
struct shared_ptr
{
    template <typename D>
    shared_ptr(T*, D const& deleter);
};
\end{minted}

Deleter, как и счетчик ссылок, является общим для всех \mintinline{c++}{shared_ptr} ссылающихся на некоторый объект, поэтому хранится в том же блоке памяти, что и счетчик ссылок:

\begin{minted}[linenos, frame=lines, framesep=2mm, tabsize = 4, breaklines]{c++}
template <typename T>
struct shared_ptr
{
private:
    struct shared_count_base
    {
        size_t nrefs;
    };

    template <typename D>
    struct shared_count : shared_count_base
    {
        D deleter;
    };

    T* ptr;
    shared_count* ref_counter;
};
\end{minted}

\subsubsection{Aliasing конструктор}
\label{aliasing_constructor}
Иногда необходимо продлевать жизнь объекту, пока кто-то ссылается на его поля. Для этого существует специальный конструтор, называемый {\it aliasing конструктор}:

\begin{minted}[linenos, frame=lines, framesep=2mm, tabsize = 4, breaklines]{c++}
template <typename T>
struct shared_ptr
{
    // Создаёт shared_ptr ссылающийся на ptr и использующий shared_count от sp.
    template <typename U>
    shared_ptr(shared_ptr<U> const& sp, T* ptr);
};
\end{minted}

Рассмотрим использование aliasing конструктора на примере. Пусть у нас есть машина. Машина имеет колёса. Мы хотим, чтобы пока существует указатель на колесо, машина тоже не удалялась вместе с колёсами. Это можно записать следующим образом:

\begin{listing}
\begin{minted}[linenos, frame=lines, framesep=2mm, tabsize = 4, breaklines]{c++}
struct car
{
    wheel wheels[4];
};

shared_ptr<car> c;
shared_ptr<wheel> w(c, &c->wheels[2]); // w получает тот же shared_count, что и c
\end{minted}
\caption{Пример использования aliasing конструктора}
\label{listing:shared_ptr_aliasing_ctor_example}
\end{listing}

Сравним такое использование со случаем когда \mintinline{c++}{car}, содержит \mintinline{c++}{shared_ptr}'ы на \mintinline{c++}{wheel}'ы:

\begin{listing}
\begin{minted}[linenos, frame=lines, framesep=2mm, tabsize = 4, breaklines]{c++}
struct car
{
    shared_ptr<wheel> wheels[4];
};

shared_ptr<car> c;
shared_ptr<wheel> w(c->wheels[2]);
\end{minted}
\caption{Пример с автомобилем и колёсами без использования aliasing конструктора}
\label{listing:shared_ptr_car_wheels_example}
\end{listing}

Примеры \ref{listing:shared_ptr_aliasing_ctor_example} и \ref{listing:shared_ptr_car_wheels_example} имеют два отличия:
\begin{enumerate}
\item В примере \ref{listing:shared_ptr_aliasing_ctor_example} имеется один объект в памяти и один счетчик ссылок. В примере \ref{listing:shared_ptr_car_wheels_example} имеется пять объектов в памяти, каждый из которых имеет свой счетчик ссылок.
\item В примере \ref{listing:shared_ptr_aliasing_ctor_example} колёса не могут существовать без автомобиля, когда умирает автомобиль удаляются все колеса. Удерживание ссылки на колесо продлевает жизнь автомобилю. В примере \ref{listing:shared_ptr_car_wheels_example} автомобиль может умереть, а колеса будут продолжать жить сами по себе.
\end{enumerate}

Для того, чтобы поддержать aliasing конструкторы в \mintinline{c++}{shared_count}'е требуется похранить ссылку на исходный объект:

\begin{minted}[linenos, frame=lines, framesep=2mm, tabsize = 4, breaklines]{c++}
template <typename T>
struct shared_ptr
{
private:
    struct shared_count_base
    {
        size_t nrefs;
    };

    template <typename D>
    struct shared_count : shared_count_base
    {
        T* ptr;
        D deleter;
    };

    T* ptr;
    shared_count* ref_counter;
};
\end{minted}

Ещё одним применением aliasing конструкторов является следующее. При хранении дерева объектов они позволяют, гарантировать, что пока существует хоть один указатель на элемент дерева, то всё дерево продолжает существовать.

\subsubsection{\mintinline{c++}{std::weak_ptr}}
\label{weak_ptr}

Рассмотрим следующую задачу. Пусть у нас есть функция \mintinline{c++}{image load_image(string name)} загружающая картинку по имени. И пусть так оказалось, что часто пользователи этой функции загружают одну и ту же картинку несколько раз и держать в памяти несколько копий одной картинки. Требуется сделать компонент, который если изображение уже загружено, не будет загружать его второй раз, а будет переиспользовать существующее. Освобождаться изображение должно только тогда, когда последний пользователь закончил с ним работать.

Чтобы изображение удалялось только тогда, когда последний пользователь закончил с ним работать изменим пользователей, чтобы они хранили не сам \mintinline{c++}{image}, а \mintinline{c++}{shared_ptr<image>}. Для того, чтобы \mintinline{c++}{load_image} возвращала \mintinline{c++}{shared_ptr} на уже существующий \mintinline{c++}{image} если такой существует можно было бы попробовать использовать мапу:

\begin{listing}
\begin{minted}[linenos, frame=lines, framesep=2mm, tabsize = 4, breaklines]{c++}
struct image_cache
{
    image_cache(image_cache const&) = delete;
    image_cache& operator=(image_cache const&) = delete;

    std::shared_ptr<image> load_image(std::string const& name)
    {
        auto i = cache.find(name);
        if (i != cache.end())
            return i->second;

        std::shared_ptr<image> p = real_load_image(name);
        cache.insert(i, {name, p});
        return p;
    }

private:
    std::map<std::string, std::shared_ptr<image> > cache;
};
\end{minted}
\caption{Пример (некорректный) кеша изображений}
\label{listing:shared_ptr_image_cache_broken}
\end{listing}

Однако использование \mintinline{c++}{shared_ptr<image>} в кеше приводит к проблеме. \mintinline{c++}{shared_ptr} мешает \mintinline{c++}{image}'ам удаляться, поскольку на все \mintinline{c++}{image}'ы как минимум держатся ссылки из кеша. В результате все загруженные изображения будут удерживаться, пока живет \mintinline{c++}{image_cache}.

Для решения этой задачи требуется класс который позволяет ссылаться на \mintinline{c++}{image}, но не удерживать ссылку на него. Таким классом является \mintinline{c++}{std::weak_ptr}. \mintinline{c++}{weak_ptr} используется совместно с \mintinline{c++}{shared_ptr} и позволяет ссылаться на объект не препятствуя его удалению.

\mintinline{c++}{weak_ptr} имеет следующие операции:

\begin{minted}[linenos, frame=lines, framesep=2mm, tabsize = 4, breaklines]{c++}
template <typename T>
struct weak_ptr
{
    // создает weak_ptr не ссылающийся ни на один объект
    weak_ptr();
    // создает weak_ptr ссылающийся на тот же объект, что и sp
    weak_ptr(shared_ptr<T> const& sp);

    weak_ptr(weak_ptr const& other);
    weak_ptr& operator=(weak_ptr const& other);

    // Возвращает нулевой shared_ptr, если объект был удалён
    // Возвращает ненулевой shared_ptr, если объект ещё не был удален
    shared_ptr<T> lock() const;
};
\end{minted}

\mintinline{c++}{weak_ptr} не имеет операции разыменования.

С использованием \mintinline{c++}{weak_ptr} пример \ref{listing:shared_ptr_image_cache_broken} можно переписать следующим образом:

\begin{minted}[linenos, frame=lines, framesep=2mm, tabsize = 4, breaklines]{c++}
struct image_cache
{
    image_cache(image_cache const&) = delete;
    image_cache& operator=(image_cache const&) = delete;

    std::shared_ptr<image> load_image(std::string const& name)
    {
        auto i = cache.find(name);
        if (i != cache.end())
        {
            std::shared_ptr<image> p = i->second.lock();
            if (p)
                return p;
        }

        std::shared_ptr<image> p = real_load_image(name);
        cache[name] = p;
        return p;
    }

private:
    std::map<std::string, std::weak_ptr<image> > cache;
};
\end{minted}

Для поддержки \mintinline{c++}{weak_ptr}, \mintinline{c++}{shared_count} содержит два счетчика ссылок: один для обычных (сильных) ссылок и один для слабых ссылок. Достижение счетчика сильных нуля влечет удаление управляемого объекта, достичение обоих счетчиков нуля влечет удаление \mintinline{c++}{shared_count}'а.

\subsection{Приведение умных указателей}

Встроенные операторы приведения типа \mintinline{c++}{static_cast}, \mintinline{c++}{dynamic_cast}, \mintinline{c++}{reinterpret_cast}, \mintinline{c++}{const_cast} определены для обычных указателей. Для умных они либо не работают (\mintinline{c++}{dynamic_cast}, \mintinline{c++}{reinterpret_cast}, \mintinline{c++}{const_cast}), либо делают другую операцию (\mintinline{c++}{static_cast}).

Что делать если существует например \mintinline{c++}{shared_ptr<B>} и ему требуется сделать \mintinline{c++}{dynamic_cast} к \mintinline{c++}{shared_ptr<D>}? Наивная попытка могла бы выглядеть следующим образом:

\begin{minted}[linenos, frame=lines, framesep=2mm, tabsize = 4, breaklines]{c++}
shared_ptr<B> base;
shared_ptr<D> derived = shared_ptr<D>(dynamic_cast<D*>(base.get()));
\end{minted}

Однако данный код приводит к разделению счетчика ссылок (\ref{reference_counter_split_problem}). Чтобы не разделять счетчик ссылок следует использовать aliasing конструктор (\ref{aliasing_constructor}):

\begin{listing}
\begin{minted}[linenos, frame=lines, framesep=2mm, tabsize = 4, breaklines]{c++}
shared_ptr<B> base;
shared_ptr<D> derived = shared_ptr<D>(base, dynamic_cast<D*>(base.get()));
\end{minted}
\caption{Использование aliasing конструктора для \mintinline{c++}{dynamic_cast}'а \mintinline{c++}{shared_ptr}'ов}
\label{listing:downcasting_using_aliasing_constructor}
\end{listing}

В стандартной библиотеке существуют функции использующие aliasing конструктор и делающие приведение типов. Они называются \mintinline{c++}{static_pointer_cast}, \mintinline{c++}{dynamic_pointer_cast} и \mintinline{c++}{const_pointer_cast}. \mintinline{c++}{reinterpret_pointer_cast} присутствует в библиотеке Boost, но по какой-то причине отсутствует в стандартной библиотеке.

С использованием \mintinline{c++}{dynamic_pointer_cast} пример \ref{listing:downcasting_using_aliasing_constructor} может быть переписан следующим образом:
\begin{minted}[linenos, frame=lines, framesep=2mm, tabsize = 4, breaklines]{c++}
shared_ptr<B> base;
shared_ptr<D> derived = dynamic_pointer_cast<D>(base);
\end{minted}

\subsection{\mintinline{c++}{std::make_shared} / \mintinline{c++}{std::make_unique}}
\label{make_shared}

Рассмотрим следующий пример кода:

\begin{minted}[linenos, frame=lines, framesep=2mm, tabsize = 4, breaklines]{c++}
shared_ptr<mytype> sp(new mytype(1, 2, 3));
\end{minted}

Данный код аллоцирует два объекта в куче. Один при создании \mintinline{c++}{new mytype}, второй --- внутри конструктора \mintinline{c++}{shared_ptr(T*)} для аллокации \mintinline{c++}{shared_count}. Это означает, что такое использование \mintinline{c++}{shared_ptr}'ов удваивает число аллокаций памяти. Это может негативно повлиять на производительность программы поскольку
\begin{itemize}
    \item Аллокации/освобождения памяти не самые быстрые операции, а их начинает делаться в два раза больше.
    \item Удваивается число существующих объектов в памяти о которых нужно знать аллокатору памяти, что может увеличить время работы операций аллокации/освобождения.
\end{itemize}

Для решения этой проблемы существует специальная функция называемая \mintinline{c++}{make_shared}. \mintinline{c++}{make_shared} имеет следующую сигнатуру:

\begin{minted}[linenos, frame=lines, framesep=2mm, tabsize = 4, breaklines]{c++}
template<typename T, typename... Args>
shared_ptr<T> make_shared(Args&&... args);
\end{minted}

\mintinline{c++}{make_shared} создает объект типа \mintinline{c++}{T} и возвращает \mintinline{c++}{shared_ptr} на него. При это \mintinline{c++}{make_shared} делает это используя лишь одну аллокацию памяти то есть и объект и \mintinline{c++}{shared_count} выделяются в одном блоке памяти.

Использование \mintinline{c++}{make_shared} поволяет приблизить \mintinline{c++}{shared_ptr} по эффективности к \mintinline{c++}{intrusive_ptr}. При этом всё равно сохраняется то негативное свойство, что каждый \mintinline{c++}{shared_ptr} хранит два указателя, а не один как у \mintinline{c++}{intrusive_ptr}.

Отдельно следует упомянуть о взаимодействии \mintinline{c++}{make_shared} и \mintinline{c++}{weak_ptr}. Когда управляемый объект и \mintinline{c++}{shared_count} выделены как два разных объекта, управляемый объект удаляется, когда число сильных ссылок достигает нуля, а \mintinline{c++}{shared_count} --- когда число ссылок обоего типа достигает нуля. При использовании \mintinline{c++}{make_shared} эти объекты выделены одним блоком памяти поэтому их невозможно освободить независимо. При использовании \mintinline{c++}{make_shared}, когда число сильных ссылок достигает нуля у управляемого объекта вызывается лишь деструктор, а память не освобождается. Память будет освобождена, когда число ссылок обоего типа достигнет нуля. Поэтому в случае когда управляемый объект большой и существуют \mintinline{c++}{weak_ptr}'ы на него, которые живут сильно дольше чем \mintinline{c++}{shared_ptr}'ы возможно имеет смысл не использовать \mintinline{c++}{make_shared}.

Появление \mintinline{c++}{make_shared} решило ещё одну проблему. Рассмотрим следующий пример:

\begin{minted}[linenos, frame=lines, framesep=2mm, tabsize = 4, breaklines]{c++}
f(std::shared_ptr<T>(1, 2, 3), g());
\end{minted}

Стандарт C++ не предписывает определенного порядка вычисления аргументов функции, причём не гарантируется, что один аргумент полностью вычислился перед тем как начнёт вычисляться другой. Например, допустимым порядком вычисления аргументов является \mintinline{c++}{new T} затем \mintinline{c++}{g()} и затем \mintinline{c++}{shared_ptr(T*)}. Следовательно если \mintinline{c++}{g()} бросит исключение, то аллокация \mintinline{c++}{new T} освобождена не будет. \mintinline{c++}{make_shared} позволяет избежать этой проблемы:

\begin{minted}[linenos, frame=lines, framesep=2mm, tabsize = 4, breaklines]{c++}
f(std::make_shared<T>(1, 2, 3), g());
\end{minted}

В данном случае в каком бы порядке не вычислялись аргументы утечка памяти невозможна, поскольку операция аллокации объекта и оборачивания его в \mintinline{c++}{shared_ptr} не может быть разделена операцией бросающей исключение.

Начиная с C++14 аналогичная функция-фабрика \mintinline{c++}{std::make_unique} была добавлена для \mintinline{c++}{std::unique_ptr}. С появлением \mintinline{c++}{make_shared} и \mintinline{c++}{make_unique} необходимость делать \mintinline{c++}{new} а затем оборачивать результат в умный указатель отпала, что являлось наиболее частым применением \mintinline{c++}{new}. Поэтому начиная с C++14 необходимость использовать голый \mintinline{c++}{new} практически не встречается за редким исключением низкоуровневого кода управляющего временем жизни объектов вручную.

\subsection{\mintinline{c++}{std::enable_shared_from_this}}
\label{enable_shared_from_this}

В некоторых случаях требуется иметь возможность получить \mintinline{c++}{shared_ptr} на \mintinline{c++}{this} внутри функций-членов класса. Взять указатель \mintinline{c++}{this} и обернуть его в \mintinline{c++}{shared_ptr} не сработает --- это приведет к разделению счетчика ссылок (раздел \ref{reference_counter_split_problem}).

Для решения этой проблемы существует специальный класс называющийся \mintinline{c++}{std::enable_shared_from_this}. Для его использования требуется отнаследовать тот класс, внутри которого необходимо получать \mintinline{c++}{shared_ptr} на \mintinline{c++}{this}, от \mintinline{c++}{std::enable_shared_from_this}:

\begin{minted}[linenos, frame=lines, framesep=2mm, tabsize = 4, breaklines]{c++}
struct mytype : std::enable_shared_from_this<mytype>
{
    shared_ptr<mytype> foo() const
    {
        return shared_from_this();
    }
};
\end{minted}

Наследование от \mintinline{c++}{std::enable_shared_from_this} изменяет поведение конструктора \mintinline{c++}{shared_ptr(T*)}. Если \mintinline{c++}{T} наследуется от \mintinline{c++}{enable_shared_from_this<T>}, он не создает новый \mintinline{c++}{shared_count}, а переиспользует существующий. Внутри \mintinline{c++}{enable_shared_from_this} хранит \mintinline{c++}{weak_ptr}:

\begin{minted}[linenos, frame=lines, framesep=2mm, tabsize = 4, breaklines]{c++}
template <typename T>
struct enable_shared_from_this
{
    shared_ptr<T> shared_from_this()
    {
        return shared_ptr<T>(weak_this);
    }

private:
    weak_ptr<T> weak_this;
};
\end{minted}

Для удобства \mintinline{c++}{enable_shared_from_this} содержит функции \mintinline{c++}{shared_from_this()} и \mintinline{c++}{weak_from_this()} возвращающие \mintinline{c++}{shared_ptr} и \mintinline{c++}{weak_ptr} на \mintinline{c++}{this} соответственно.

Конструктор \mintinline{c++}{shared_ptr(T*)} использует SFINAE-проверки для определения наследования от \mintinline{c++}{enable_shared_from_this}, поэтому для того, чтобы \mintinline{c++}{enable_shared_from_this} работал корректо необходимо, наследоваться от него public и чтобы существовал ровно один базовый subobject этого типа.

Запись в \mintinline{c++}{enable_shared_from_this::weak_this} делается при создании первого \mintinline{c++}{shared_ptr}, а зануляется \mintinline{c++}{enable_shared_from_this::weak_this} когда на объект перестает ссылаться последний \mintinline{c++}{shared_ptr}, следовательно использовать \mintinline{c++}{shared_from_this()} внутри конструктора и внутри деструктора нельзя. Если это сделать будет выброшено исключение \mintinline{c++}{std::bad_weak_ptr}.

\subsection{\mintinline{c++}{boost::intrusive_ptr}}

\mintinline{c++}{boost::intrusive_ptr} --- умный указатель с разделяемым владением, реализованный в библиотеке Boost. Так же как и \mintinline{c++}{std::shared_ptr}, он использует подсчет ссылок, но в отличии от \mintinline{c++}{std::shared_ptr} в \mintinline{c++}{boost::intrusive_ptr<T>} счетчик ссылок хранится в самом объекте класса T, на который он ссылается.

Для использования \mintinline{c++}{intrusive_ptr} с пользовательским типом \mintinline{c++}{mytype} требуется реализовать две функции:

\begin{minted}[
linenos,
frame=lines,
framesep=2mm]
{c++}
void intrusive_ptr_add_ref(mytype* p);
void intrusive_ptr_release(mytype* p);
\end{minted}

Функция \mintinline{c++}{intrusive_ptr_add_ref} вызывается, когда требуется увеличить счетчик ссылок. Функция \mintinline{c++}{intrusive_ptr_release} вызывается тогда, когда требуется его уменьшить и если он достигает нуля, то функция \mintinline{c++}{intrusive_ptr_release} должна самостоятельно удалить объект.

Пример использования:

\begin{minted}[
linenos,
frame=lines,
framesep=2mm]
{c++}
#include <boost/intrusive_ptr.hpp>

struct mytype
{
    int ref_count;
};

void intrusive_ptr_add_ref(mytype *p)
{
    ++p->ref_count;
}

void intrusive_ptr_release(mytype *p)
{
    if (--p->ref_count == 0)
        delete p;
}

int main()
{
    // аллоцированный объект будет удален при выходе из main
    boost::intrusive_ptr<mytype> p(new mytype());
}
\end{minted}

По сравнению с \mintinline{c++}{shared_ptr}, \mintinline{c++}{boost::intrusive_ptr} не накладывает ограничений на тип счетчика ссылок. Например, возможно использовать не thread-safe переменную в качестве счетчика ссылок, если известно, что все владельцы объекта работают в одном потоке. Также объекты типа \mintinline{c++}{intrusive_ptr} занимаю один указатель, а не два как у \mintinline{c++}{shared_ptr}. Поэтому можно сказать, что \mintinline{c++}{intrusive_ptr} эффективнее чем \mintinline{c++}{shared_ptr}, однако он не поддерживает такие возможности \mintinline{c++}{shared_ptr} как \mintinline{c++}{weak_ptr} (раздел \ref{weak_ptr}) и настраиваемый deleter (раздел \ref{shared_ptr_custom_deleter}).