std::allocate_shared, std::allocate_shared_for_overwrite

template< class T, class Alloc, class... Args >
shared_ptr<T> allocate_shared( const Alloc& alloc, Args&&... args );

template< class T, class Alloc >
shared_ptr<T> allocate_shared( const Alloc& alloc, std::size_t N );

template< class T, class Alloc >
shared_ptr<T> allocate_shared( const Alloc& alloc );

template< class T, class Alloc >
shared_ptr<T> allocate_shared( const Alloc& alloc, std::size_t N,
                               const std::remove_extent_t<T>& u );

template< class T, class Alloc >
shared_ptr<T> allocate_shared( const Alloc& alloc,
                               const std::remove_extent_t<T>& u );

template< class T, class Alloc >
shared_ptr<T> allocate_shared_for_overwrite( const Alloc& alloc );

template< class T, class Alloc >
shared_ptr<T> allocate_shared_for_overwrite( const Alloc& alloc,
                                             std::size_t N );

Выделяет память для объекта с помощью копии alloc (перепривязанной к неопределённому value_type) и инициализирует объект переданными аргументами. Возвращает объект std::shared_ptr, управляющий созданным объектом.

• Если T не является типом массива, объект конструируется так, как если бы был вызван ::new (pv) T, где pv — указатель void* на хранилище, подходящее для размещения объекта типа T. Если объект подлежит уничтожению, он уничтожается так, как если бы был вызван pt->~T(), где pt — указатель на этот объект типа T.
• Если T является массивом известной границы, начальное значение каждого элемента не определено.

Параметры

Возвращаемое значение

std::shared_ptr на объект типа T или std::remove_extent_t<T>[N], если T является массивом неизвестной границы(начиная с C++20).

Для возвращённого std::shared_ptr r функция r.get() возвращает ненулевой указатель, а r.use_count() возвращает 1.

Исключения

Могут быть выброшены исключения, выбрасываемые из Alloc::allocate() или конструктора T. Если выбрасывается исключение, (1) не оказывает эффекта. Если при конструировании массива выбрасывается исключение, уже инициализированные элементы уничтожаются в обратном порядке(начиная с C++20).

Примечания

Эти функции обычно выделяют больше памяти, чем sizeof(T), чтобы разместить внутренние структуры учёта, например счётчики ссылок.

Как и std::make_shared, эта функция обычно выполняет только одно выделение памяти и размещает объект T и управляющий блок в выделенном блоке памяти (стандарт рекомендует, но не требует этого; так поступают все известные реализации). Копия alloc хранится в управляющем блоке, чтобы её можно было использовать для освобождения памяти после обнуления счётчиков совместных и слабых ссылок.

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

Конструктор включает shared_from_this с указателем ptr типа U* означает, что он определяет, имеет ли U однозначный и доступный(начиная с C++17) базовый класс, являющийся специализацией std::enable_shared_from_this, и, если имеет, конструктор вычисляет if(ptr!=nullptr&&ptr->weak_this .expired())
    ptr->weak_this =std::shared_ptr<std::remove_cv_t<U>>
        (*this,const_cast<std::remove_cv_t<U>*>(ptr)); .

Присваивание weak_this не является атомарным и конфликтует с любым потенциально параллельным доступом к тому же объекту. Это гарантирует, что последующие вызовы shared_from_this() будут совместно владеть объектом с std::shared_ptr, созданным этим конструктором из сырого указателя.

Проверка ptr->weak_this .expired() в коде выше гарантирует, что weak_this не будет переназначен, если он уже указывает на владельца. Эта проверка обязательна начиная с C++17.

Пример

#include <cstddef>
#include <iostream>
#include <memory>
#include <memory_resource>
#include <vector>

class Value
{
    int i;
public:
    Value(int i) : i(i) { std::cout << "Value(), i = " << i << '\n'; }
    ~Value() { std::cout << "~Value(), i = " << i << '\n'; }
    void print() const { std::cout << "i = " << i << '\n'; }
};

int main()
{
    // Create a polymorphic allocator using the monotonic buffer resource
    std::byte buffer[sizeof(Value) * 8];
    std::pmr::monotonic_buffer_resource resource(buffer, sizeof(buffer));
    std::pmr::polymorphic_allocator<Value> allocator(&resource);
    
    std::vector<std::shared_ptr<Value>> v;
    
    for (int i{}; i != 4; ++i)
        // Use std::allocate_shared with the custom allocator
        v.emplace_back(std::allocate_shared<Value>(allocator, i));
    
    for (const auto& sp : v)
        sp->print();
} //< All shared pointers will automatically clean up when they go out of scope.

Value(), i = 0
Value(), i = 1
Value(), i = 2
Value(), i = 3
i = 0
i = 1
i = 2
i = 3
~Value(), i = 0
~Value(), i = 1
~Value(), i = 2
~Value(), i = 3

Отчёты об ошибках

Следующие отчёты об ошибках, изменяющие поведение, были ретроактивно применены к ранее опубликованным стандартам C++.

См. также