std::shared_ptr

 

C++

Поддержка компилятором

Автономные и размещённые реализации

Язык

Заголовки стандартной библиотеки

Требования к именованию

Макросы тестирования функциональности (C++20)

Поддержка языка

Библиотека концептов (C++20)

Библиотека диагностики

Библиотека общих утилит

Библиотека строк

Библиотека контейнеров

Библиотека итераторов

Библиотека диапазонов (C++20)

Библиотека алгоритмов

Библиотека численных данных

Библиотека ввода/вывода

Библиотека локализаций

Регулярные выражения (C++11)

Атомарные операции (C++11)

Библиотека поддержки конкуренции (C++11)

Библиотека файловой системы (C++17)

Технические спецификации

Указатель символов

Внешние библиотеки

 

Библиотека утилит

Поддержка языка Поддержка типа (базовые типы, RTTI, свойства типов)     Макросы тестирования функциональности библиотеки (C++20) Управление динамической памятью Программные утилиты Обработка ошибок Поддержка сопрограмм (C++20) Вариативные функции is_constant_evaluated (C++20) launder (C++17) initializer_list (C++11) source_location (C++20) unreachable (C++23) Трёхстороннее сравнение (C++20) three_way_comparablethree_way_comparable_with (C++20)(C++20) strong_ordering (C++20) weak_ordering (C++20) partial_ordering (C++20) common_comparison_category (C++20) compare_three_way_result (C++20) compare_three_way (C++20) strong_order (C++20) weak_order (C++20) partial_order (C++20) compare_strong_order_fallback (C++20) compare_weak_order_fallback (C++20) compare_partial_order_fallback (C++20) is_eqis_neqis_ltis_lteqis_gtis_gteq (C++20)(C++20)(C++20)(C++20)(C++20)(C++20)

Общие утилиты Дата и время Объекты функции bitset Библиотека форматирования (C++20) hash (C++11) integer_sequence (C++14) Операторы отношения (устарело в C++20) rel_ops::operator!=rel_ops::operator> rel_ops::operator<=rel_ops::operator>= Целочисленные функции сравнения cmp_equalcmp_lesscmp_less_than (C++20)(C++20)(C++20)   cmp_not_equalcmp_greatercmp_greater_than (C++20)(C++20)(C++20) in_range (C++20) Операции обмена и типа swap ranges::swap (C++20) exchange (C++14) declval (C++11) forward (C++11) move (C++11) move_if_noexcept (C++11) as_const (C++17) to_underlying (C++23) Общие лексические типы pair tuple (C++11) apply (C++17) make_from_tuple (C++17) optional (C++17) any (C++17) variant (C++17) expected (C++23) Элементарные преобразования строк to_chars (C++17) from_chars (C++17) chars_format (C++17)

 

Динамическое управление памятью

Умные указатели unique_ptr (C++11) shared_ptr (C++11) weak_ptr (C++11) auto_ptr (до C++17) owner_less (C++11) enable_shared_from_this (C++11) bad_weak_ptr (C++11) default_delete (C++11) out_ptr_t (C++23) inout_ptr_t (C++23) Аллокаторы allocator allocator_traits (C++11) allocation_result (C++23) allocate_at_least (C++23) allocator_arg_t (C++11) allocator_arg (C++11) uses_allocator (C++11) uses_allocator_construction_args (C++20) make_obj_using_allocator (C++20) uninitialized_construct_using_allocator (C++20) scoped_allocator_adaptor (C++11) pmr::polymorphic_allocator (C++17) Ресурсы памяти pmr::memory_resource (C++17) pmr::get_default_resource (C++17) pmr::set_default_resource (C++17) pmr::new_delete_resource (C++17) pmr::null_memory_resource (C++17) pmr::synchronized_pool_resource (C++17) pmr::unsynchronized_pool_resource (C++17) pmr::monotonic_buffer_resource (C++17) pmr::pool_options (C++17) Неинициализированное хранилище raw_storage_iterator (до C++20) get_temporary_buffer (до C++20) return_temporary_buffer (до C++20)

Алгоритмы неинициализированной памяти uninitialized_copy uninitialized_fill uninitialized_move (C++17) uninitialized_default_construct (C++17) uninitialized_value_construct (C++17) destroy (C++17) destroy_at (C++17) uninitialized_copy_n (C++11) uninitialized_fill_n uninitialized_move_n (C++17) uninitialized_default_construct_n (C++17) uninitialized_value_construct_n (C++17) destroy_n (C++17) construct_at (C++20) Ограниченные алгоритмы неинициализированной памяти ranges::uninitialized_copy (C++20) ranges::uninitialized_fill (C++20) ranges::uninitialized_move (C++20) ranges::uninitialized_default_construct (C++20) ranges::uninitialized_value_construct (C++20) ranges::destroy (C++20) ranges::destroy_at (C++20) ranges::uninitialized_copy_n (C++20) ranges::uninitialized_fill_n (C++20) ranges::uninitialized_move_n (C++20) ranges::uninitialized_default_construct_n (C++20) ranges::uninitialized_value_construct_n (C++20) ranges::destroy_n (C++20) ranges::construct_at (C++20) Поддержка сборки мусора declare_reachable (C++11)(до C++23) undeclare_reachable (C++11)(до C++23) declare_no_pointers (C++11)(до C++23) undeclare_no_pointers (C++11)(до C++23) pointer_safety (C++11)(до C++23) get_pointer_safety (C++11)(до C++23) Разное pointer_traits (C++11) to_address (C++20) addressof (C++11) align (C++11) assume_aligned (C++20) Библиотека C malloc aligned_alloc (C++17) calloc realloc free Низкоуровневое управление памятью operator new operator new[] operator delete operator delete[] get_new_handler set_new_handler bad_alloc bad_array_new_length nothrow_t align_val_t destroying_delete_t new_handler nothrow

 

std::shared_ptr

Функции-элементы

shared_ptr::shared_ptr

shared_ptr::~shared_ptr

shared_ptr::operator=

Модификаторы

shared_ptr::reset

shared_ptr::swap

Наблюдатели

shared_ptr::get

shared_ptr::operator*shared_ptr::operator->

shared_ptr::operator[] (C++17)

shared_ptr::use_count

shared_ptr::unique (до C++20)

shared_ptr::operator bool

shared_ptr::owner_before

Функции, не являющиеся элементами

std::swap

make_sharedmake_shared_for_overwrite (C++20)

allocate_sharedallocate_shared_for_overwrite (C++20)

static_pointer_castdynamic_pointer_castconst_pointer_castreinterpret_pointer_cast (C++17)

get_deleter

operator==operator!=operator<operator<=operator>operator>=operator<=> (до C++20)(до C++20)(до C++20)(до C++20)(до C++20)(C++20)

operator<<

atomic_xxx functions (deprecated in C++20)

std::atomic<std::shared_ptr> (C++20)

std::hash

Руководства по выводу (C++17)

 

Определено в заголовочном файле <memory>
template< class T > class shared_ptr;		(начиная с C++11)

std::shared_ptr это умный указатель, с разделяемым владением объектом через его указатель. Несколько указателей shared_ptr могут владеть одним и тем же объектом. Объект будет уничтожен и занятая им память будет освобождена в одном из следующих случаев:

• когда последний shared_ptr, владеющий указателем на объект, будет уничтожен;
• когда последнему shared_ptr, владеющему указателем на объект, будет назначен другой указатель с помощью operator= или reset().

Объект уничтожается с использованием выражения delete или с использованием пользовательской функции удаления объекта, переданной в конструктор shared_ptr.

std::shared_ptr может разделять владение объектом и в то же время хранить указатель на другой объект. Это позволяет владеть объектом и в то же время указывать на элемент этого объекта. Хранимый указатель это тот, к которому обращается get(), операторы разыменования и сравнения. Управляемый указатель это тот, который будет передан функции удаления объекта, когда счётчик владения достигнет нуля.

shared_ptr может не владеть ни одним объектом, в этом случае он называется пустым (пустой shared_ptr может иметь ненулевой сохранённый указатель, если был использован псевдонимный конструктор).

Все специализации shared_ptr отвечают требованиям CopyConstructible, CopyAssignable и LessThanComparable, а также неявно преобразуются в bool.

Все функции-элементы (включая конструктор копирования и присваивание копированием) могут быть вызваны в нескольких потоках разными экземплярами shared_ptr без дополнительной синхронизации, даже если эти экземпляры копируют и владеют одним и тем же объектом. Если несколько потоков обращаются к одному и тому же экземпляру shared_ptr без синхронизации и какое-либо обращение происходит через неконстантную функцию-элемент shared_ptr, тогда произойдёт гонка данных; для предотвращения гонки данных можно использовать перегрузку атомарных функций для shared_ptr.

Типы-элемент

Тип-элемент	Определение
element_type	T (до C++17) std::remove_extent_t<T> (начиная с C++17)
weak_type (начиная с C++17)	std::weak_ptr<T>

Функции-элементы

(конструктор)	создаёт новый shared_ptr (public функция-элемент)
(деструктор)	разрушает объект, которым владеет, если больше нет shared_ptr ссылающихся на него (public функция-элемент)
operator=	присваивает значение shared_ptr (public функция-элемент)
Модификаторы
reset	заменяет управляемый объект (public функция-элемент)
swap	обменивает управляемые объекты (public функция-элемент)
Наблюдатели
get	возвращает хранимый указатель (public функция-элемент)
operator* operator->	разыменовывает сохранённый указатель (public функция-элемент)
operator[] (C++17)	обеспечивает индексированный доступ к сохранённому массиву (public функция-элемент)
use_count	возвращает количество объектов shared_ptr, ссылающихся на один и тот же управляемый объект (public функция-элемент)
unique (до C++20)	проверяет, управляется ли управляемый объект только текущим экземпляром shared_ptr (public функция-элемент)
operator bool	проверяет, не является ли сохранённый указатель нулевым (public функция-элемент)
owner_before	обеспечивает упорядочивание общих указателей на основе владельца (public функция-элемент)

Функции, не являющиеся элементами

make_shared make_shared_for_overwrite (C++20)	создаёт общий указатель, который управляет новым объектом (шаблон функции)
allocate_shared allocate_shared_for_overwrite (C++20)	создаёт общий указатель, который управляет новым объектом, выделенным с помощью аллокатора (шаблон функции)
static_pointer_cast dynamic_pointer_cast const_pointer_cast reinterpret_pointer_cast (C++17)	применяет static_cast, dynamic_cast, const_cast или reinterpret_cast к сохранённому указателю (шаблон функции)
get_deleter	возвращает пользовательскую функцию указанного типа, если владеет (шаблон функции)
operator== operator!= operator< operator<= operator> operator>= operator<=> (убрано в C++20) (убрано в C++20) (убрано в C++20) (убрано в C++20) (убрано в C++20) (C++20)	сравнивает с другим shared_ptr или с nullptr (шаблон функции)
operator<<	выводит значение сохранённого указателя в выходной поток (шаблон функции)
std::swap(std::shared_ptr) (C++11)	специализация алгоритма std::swap (шаблон функции)

std::atomic_is_lock_free(std::shared_ptr) std::atomic_load(std::shared_ptr) std::atomic_load_explicit(std::shared_ptr) std::atomic_store(std::shared_ptr) std::atomic_store_explicit(std::shared_ptr) std::atomic_exchange(std::shared_ptr) std::atomic_exchange_explicit(std::shared_ptr) std::atomic_compare_exchange_weak(std::shared_ptr) std::atomic_compare_exchange_strong(std::shared_ptr) std::atomic_compare_exchange_weak_explicit(std::shared_ptr) std::atomic_compare_exchange_strong_explicit(std::shared_ptr) (устарело в C++20)

специализации атомарных операций для std::shared_ptr (шаблон функции)

Вспомогательные классы

std::atomic<std::shared_ptr> (C++20)	атомарный разделяемый указатель (специализация шаблона класса)
std::hash<std::shared_ptr> (C++11)	поддержка хеширования для std::shared_ptr (специализация шаблона класса)

Примечание

Владение объектом может быть разделено с другим shared_ptr только с помощью копирующего конструктора или копирующего присваивания другому shared_ptr. Создание нового shared_ptr с помощью сырого указателя, которым уже владеет другой shared_ptr, приводит к неопределённому поведению.

std::shared_ptr может быть использован с неполным типом T. В то же время принимающий сырой указатель конструктор (template<class Y> shared_ptr(Y*)) и функция-элемент template<class Y> void reset(Y*) могут быть вызваны только с указателем на полный тип (заметим, что конструктор std::unique_ptr может быть вызван с сырым указателем на неполный тип).

Тип T в std::shared_ptr<T> может быть функцией: в этом случае он владеет указателем на функцию вместо указателя на объект. Это иногда используется, чтобы держать динамическую библиотеку или плагин загруженными, пока указатель ссылается на принадлежащие им функции:

void del(void(*)()) {}
void fun() {}
int main(){
  std::shared_ptr<void()> ee(fun, del);
  (*ee)();
}

Примечания по реализации

В типичной реализации, std::shared_ptr содержит только два указателя:

• сохранённый указатель (возвращаемый функцией get());
• указатель на блок управления

Блок управления это динамически выделяемый объект, который содержит:

• указатель на управляемый объект или сам управляемый объект;
• функцию удаления объекта (удаляется по типу);
• аллокатор (удаляется по типу);
• количество shared_ptr, владеющих управляемым объектом;
• количество weak_ptr, которые ссылаются на управляемый объект;

Когда shared_ptr создаётся путём вызова std::make_shared или std::allocate_shared, память как для блока управления, так и для управляемого объекта создаётся с помощью одного аллокатора. Управляемый объект создаётся на месте в элементе данных блока управления. Когда shared_ptr создаётся с помощью одного из конструкторов shared_ptr, управляемый объект и блок управления должны создаваться отдельно. В этом случае блок управления хранит указатель на управляемый объект.

Указатель, удерживаемый непосредственно shared_ptr, является указателем, возвращаемым get(), в то время как указатель/объект, удерживаемый блоком управления, является тем, который будет удалён, когда количество общих владельцев дойдёт до нуля. Эти указатели не обязательно равны.

Деструктор shared_ptr уменьшает количество совместно используемых владельцев блока управления. Если этот счётчик достигает нуля, блок управления вызывает деструктор управляемого объекта. Блок управления не освобождается, пока счётчик std::weak_ptr также не достигнет нуля.

В существующих реализациях количество слабых указателей увеличивается ([1], [2]), если есть общий указатель на тот же блок управления.

Чтобы удовлетворить требования безопасности потоков, счётчики ссылок обычно инкрементируются с использованием эквивалента std::atomic::fetch_add с std::memory_order_relaxed (декремент требует более строгого упорядочивания для безопасного уничтожения блока управления).

Пример

Запустить этот код

#include <iostream>
#include <memory>
#include <thread>
#include <chrono>
#include <mutex>
 
struct Base
{
    Base() { std::cout << "  Base::Base()\n"; }
    // Примечание: невиртуальный деструктор здесь правилен
    ~Base() { std::cout << "  Base::~Base()\n"; }
};
 
struct Derived: public Base
{
    Derived() { std::cout << "  Derived::Derived()\n"; }
    ~Derived() { std::cout << "  Derived::~Derived()\n"; }
};
 
void thr(std::shared_ptr<Base> p)
{
    std::shared_ptr<Base> lp = p; // потокобезопасно, даже если
                                  // общий use_count инкрементируется
    {
        static std::mutex io_mutex;
        std::lock_guard<std::mutex> lk(io_mutex);
        std::cout << "локальный указатель в потоке:\n"
                  << "  lp.get() = " << lp.get()
                  << ", lp.use_count() = " << lp.use_count() << '\n';
    }
}
 
int main()
{
    std::shared_ptr<Base> p = std::make_shared<Derived>();
 
    std::cout << "Создан общий Derived (как указатель на Base)\n"
              << "  p.get() = " << p.get()
              << ", p.use_count() = " << p.use_count() << '\n';
    std::thread t1(thr, p), t2(thr, p), t3(thr, p);
    p.reset(); // освободить владение функцией main
    std::cout << "Создать совместное владение между 3-мя потоками и освободить\n"
              << "владение функцией main:\n"
              << "  p.get() = " << p.get()
              << ", p.use_count() = " << p.use_count() << '\n';
    t1.join(); t2.join(); t3.join();
    std::cout << "Все потоки завершены, последним удалён Derived\n";
}

Возможный вывод:

Base::Base()
  Derived::Derived()
Создан общий Derived (как указатель на Base)
  p.get() = 0x2299b30, p.use_count() = 1
Создать совместное владение между 3-мя потоками и освободить
владение функцией main:
  p.get() = 0, p.use_count() = 0
локальный указатель в потоке:
  lp.get() = 0x2299b30, lp.use_count() = 5
локальный указатель в потоке:
  lp.get() = 0x2299b30, lp.use_count() = 3
локальный указатель в потоке:
  lp.get() = 0x2299b30, lp.use_count() = 2
  Derived::~Derived()
  Base::~Base()
Все потоки завершены, последним удалён Derived

Смотрите также

unique_ptr (C++11)	умный указатель с уникальной семантикой владения объектом (шаблон класса)
weak_ptr (C++11)	слабая ссылка на объект, управляемый std::shared_ptr (шаблон класса)