std::shared_ptr<T>:: shared_ptr

Создает новый shared_ptr из различных типов указателей, ссылающихся на управляемый объект.

Когда T не является типом массива, перегрузки (3,4,6) активируют shared_from_this с ptr , а перегрузка (13) активирует shared_from_this с указателем, возвращаемым r. release ( ) .

Параметры

Постусловия

Исключения

Примечания

Конструктор активирует 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.

Перегрузки с сырыми указателями принимают владение объектом, на который указывают. Поэтому создание shared_ptr с использованием перегрузки для сырого указателя для объекта, который уже управляется shared_ptr , например через shared_ptr ( ptr. get ( ) ) , вероятно приведёт к неопределённому поведению, даже если объект имеет тип, унаследованный от std::enable_shared_from_this .

Поскольку конструктор по умолчанию является constexpr , статические shared_ptrs инициализируются как часть статической нелокальной инициализации , до начала любой динамической нелокальной инициализации. Это делает безопасным использование shared_ptr в конструкторе любого статического объекта.

В C++11 и C++14 допустимо создавать std:: shared_ptr < T > из std:: unique_ptr < T [ ] > :

std::unique_ptr<int[]> arr(new int[1]);
std::shared_ptr<int> ptr(std::move(arr));

` сохранен без изменений, так как содержит C++ код, который не должен переводиться согласно инструкциям. HTML структура и атрибуты также сохранены в оригинальном виде.

Поскольку shared_ptr получает свой удалитель (объект std:: default_delete < T [ ] > ) из std::unique_ptr , массив будет корректно освобожден.

Это больше не разрешено в C++17. Вместо этого следует использовать форму массива std:: shared_ptr < T [ ] > .

Пример

#include <iostream>
#include <memory>
struct Foo
{
    int id{0};
    Foo(int i = 0) : id{i} { std::cout << "Foo::Foo(" << i <<  ")\n"; }
    ~Foo() { std::cout << "Foo::~Foo(), id=" << id << '\n'; }
};
struct D
{
    void operator()(Foo* p) const
    {
        std::cout << "Call delete from function object. Foo::id=" << p->id << '\n';
        delete p;
    }
};
int main()
{
    {
        std::cout << "1) constructor with no managed object\n";
        std::shared_ptr<Foo> sh1;
    }
    {
        std::cout << "2) constructor with object\n";
        std::shared_ptr<Foo> sh2(new Foo{10});
        std::cout << "sh2.use_count(): " << sh2.use_count() << '\n';
        std::shared_ptr<Foo> sh3(sh2);
        std::cout << "sh2.use_count(): " << sh2.use_count() << '\n';
        std::cout << "sh3.use_count(): " << sh3.use_count() << '\n';
    }
    {
        std::cout << "3) constructor with object and deleter\n";
        std::shared_ptr<Foo> sh4(new Foo{11}, D());
        std::shared_ptr<Foo> sh5(new Foo{12}, [](auto p)
        {
            std::cout << "Call delete from lambda... p->id=" << p->id << '\n';
            delete p;
        });
    }
}

1) constructor with no managed object
2) constructor with object
Foo::Foo(10)
sh2.use_count(): 1
sh2.use_count(): 2
sh3.use_count(): 2
Foo::~Foo(), id=10
3) constructor with object and deleter
Foo::Foo(11)
Foo::Foo(12)
Call delete from lambda... p->id=12
Foo::~Foo(), id=12
Call delete from function object. Foo::id=11
Foo::~Foo(), id=11

Отчеты о дефектах

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

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