enable_shared_from_this, classe

Aide à générer un shared_ptr.

Syntaxe

class enable_shared_from_this {
public:
    shared_ptr<Ty>
        shared_from_this();
    shared_ptr<const Ty> shared_from_this() const;
    weak_ptr<T> weak_from_this() noexcept;
    weak_ptr<T const> weak_from_this() const noexcept;
protected:
    enable_shared_from_this();
    enable_shared_from_this(const enable_shared_from_this&);
    enable_shared_from_this& operator=(const enable_shared_from_this&);
    ~enable_shared_from_this();
};

Paramètres

Ty
Type contrôlé par le pointeur partagé.

Notes

Les objets dérivés de enable_shared_from_this peuvent utiliser les méthodes shared_from_this dans des fonctions membres pour créer les propriétaires shared_ptr de l’instance qui partagent la propriété avec les propriétaires shared_ptr existants. Sinon, si vous créez un nouveau shared_ptr à l’aide de this, il est différent des propriétaires shared_ptr existants, ce qui peut entraîner des références non valides ou la suppression de l’objet plusieurs fois.

Les constructeurs, le destructeur et l’opérateur d’assignation sont protégés pour éviter toute mauvaise utilisation accidentelle. Le type d’argument de modèle Ty doit être le type de la classe dérivée.

Pour obtenir un exemple d’utilisation, consultez enable_shared_from_this::shared_from_this.

shared_from_this

Génère un shared_ptr qui partage la propriété de l’instance avec les propriétaires shared_ptr existants.

shared_ptr<T> shared_from_this();
shared_ptr<const T> shared_from_this() const;

Notes

Quand vous dérivez des objets à partir de la classe de base enable_shared_from_this, les fonctions membres de modèle shared_from_this retournent une classe shared_ptr qui partage la propriété de cette instance avec les propriétaires shared_ptr existants. Sinon, si vous créez un nouveau shared_ptr à partir de this, il est différent des propriétaires shared_ptr existants, ce qui peut entraîner des références non valides ou la suppression de l’objet plusieurs fois. Le comportement est indéfini si vous appelez shared_from_this sur une instance qui n’est pas déjà détenue par un objet shared_ptr.

Exemple

// std_memory_shared_from_this.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>

using namespace std;

struct base : public std::enable_shared_from_this<base>
{
    int val;
    shared_ptr<base> share_more()
    {
        return shared_from_this();
    }
};

int main()
{
    auto sp1 = make_shared<base>();
    auto sp2 = sp1->share_more();

    sp1->val = 3;
    cout << "sp2->val == " << sp2->val << endl;
    return 0;
}

sp2->val == 3

weak_from_this

weak_ptr<T> weak_from_this() noexcept;
weak_ptr<T const> weak_from_this() const noexcept;