std::shared_ptr<T>:: shared_ptr

Construit un nouveau shared_ptr à partir de divers types de pointeurs qui référencent un objet à gérer.

Lorsque T n'est pas un type tableau, les surcharges (3,4,6) activent shared_from_this avec ptr , et la surcharge (13) active shared_from_this avec le pointeur retourné par r. release ( ) .

Paramètres

Postconditions

Exceptions

Notes

Un constructeur active shared_from_this avec un pointeur ptr de type U* signifie qu'il détermine si U possède une classe de base non ambiguë et accessible (depuis C++17) qui est une spécialisation de std::enable_shared_from_this , et si c'est le cas, le constructeur évalue 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 ) ) ; .

L'assignation à weak_this n'est pas atomique et entre en conflit avec tout accès potentiellement concurrent au même objet. Cela garantit que les appels futurs à shared_from_this() partageront la propriété avec le std::shared_ptr créé par ce constructeur de pointeur brut.

Le test ptr - > weak_this  . expired ( ) dans le code ci-dessus garantit que weak_this n'est pas réaffecté s'il indique déjà un propriétaire. Ce test est requis à partir de C++17.

Les surcharges de pointeur brut prennent la propriété de l'objet pointé. Par conséquent, construire un shared_ptr en utilisant la surcharge de pointeur brut pour un objet déjà géré par un shared_ptr , comme par shared_ptr ( ptr. get ( ) ) est susceptible de conduire à un comportement indéfini, même si l'objet est d'un type dérivé de std::enable_shared_from_this .

Parce que le constructeur par défaut est constexpr , les shared_ptrs statiques sont initialisés dans le cadre de l'initialisation statique non locale , avant que toute initialisation dynamique non locale ne commence. Cela rend sûr d'utiliser un shared_ptr dans le constructeur de tout objet statique.

En C++11 et C++14, il est valide de construire un std:: shared_ptr < T > à partir d'un std:: unique_ptr < T [ ] > :

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

` et contient des termes spécifiques au C++ qui doivent être préservés. Le code reste donc identique à l'original.

Puisque le shared_ptr obtient son suppresseur (un objet std:: default_delete < T [ ] > ) du std::unique_ptr , le tableau sera correctement désalloué.

Ceci n'est plus autorisé en C++17. À la place, la forme tableau std:: shared_ptr < T [ ] > devrait être utilisée.

Exemple

#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

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

Voir aussi