shared_ptr, classe

Encapsule un pointeur intelligent avec décompte des références autour d'un objet alloué dynamiquement.

template<class Ty>
   class shared_ptr {
public:
    typedef Ty element_type;

    shared_ptr();
    shared_ptr(nullptr_t); 
    shared_ptr(const shared_ptr& sp);
    shared_ptr(shared_ptr&& sp);
    template<class Other>
        explicit shared_ptr(Other * ptr);
    template<class Other, class D>
        shared_ptr(Other * ptr, D dtor);
    template<class D>
        shared_ptr(nullptr_t, D dtor);
    template<class Other, class D, class A>
        shared_ptr(Other *ptr, D dtor, A alloc);
    template<class D, class A>
        shared_ptr(nullptr_t, D dtor, A alloc);
    template<class Other>
        shared_ptr(const shared_ptr<Other>& sp);
    template<class Other>
        shared_ptr(const shared_ptr<Other>&& sp);
    template<class Other>
        explicit shared_ptr(const weak_ptr<Other>& wp);
    template<class Other>
        shared_ptr(auto_ptr<Other>& ap);
    template<class Other, class D>
        shared_ptr(unique_ptr<Other, D>&& up);
    template<class Other>
        shared_ptr(const shared_ptr<Other>& sp, Ty *ptr);
    ~shared_ptr();
    shared_ptr& operator=(const shared_ptr& sp);
    template<class Other> 
        shared_ptr& operator=(const shared_ptr<Other>& sp);
    shared_ptr& operator=(shared_ptr&& sp);
    template<class Other> 
        shared_ptr& operator=(shared_ptr<Other>&& sp);
    template<class Other> 
        shared_ptr& operator=(auto_ptr< Other >&& ap);
    template <class Other, class D> 
        shared_ptr& operator=(const unique_ptr< Other, D>& up) = delete;
    template <class Other, class D>
        shared_ptr& operator=(unique_ptr<Other, D>&& up);
    void swap(shared_ptr& sp);
    void reset();
    template<class Other>
        void reset(Other *ptr);
    template<class Other, class D>
        void reset(Other *ptr, D dtor);
    template<class Other, class D, class A>
        void reset(Other *ptr, D dtor, A alloc);
    Ty *get() const;
    Ty& operator*() const;
    Ty *operator->() const;
    long use_count() const;
    bool unique() const;
    operator bool() const;

    template<class Other>
        bool owner_before(shared_ptr<Other> const& ptr) const;
    template<class Other>
        bool owner_before(weak_ptr<Other> const& ptr) const;
    template<class D, class Ty> 
        D* get_deleter(shared_ptr<Ty> const& ptr);
};

Paramètres

• Ty
  Le type contrôlé par le pointeur partagé.

• Other
  Le type contrôlé par le pointeur d'argument.

• ptr
  Le pointeur pour copier.

• D
  Le type de la suppression.

• A
  Le type de l'allocation.

• dtor
  La suppression.

• alloc
  L'allocateur.

• sp
  Le pointeur intelligent pour copier ou déplacer.

• wp
  Le pointeur faible pour copier ou déplacer.

• ap
  Le pointeur automatique pour copier ou déplacer.

• up
  Le pointeur unique pour déplacer.

Notes

La classe de modèle décrit un objet qui utilise le décompte de références pour gérer vos ressources. Un objet shared_ptr contient effectivement un pointeur vers la ressource qu'il possède ou contient un pointeur null. Une ressource peut être posséder par plusieurs objets shared_ptr ; lorsque le dernier objet shared_ptr qui possède une ressource particulière est détruit, la ressource est libérée.

Un shared_ptr cesse de posséder une ressource lorsqu'il est réassigné ou réinitialisé.

L'argument modèle Ty peut être de type incomplet sauf mention contraire pour certaines fonctions membres.

Lorsqu'un objet shared_ptr<Ty> est construit à partir d'un pointeur de ressources de type G* ou de shared_ptr<G>, le type pointeur G* doit être convertible en type Ty*. Dans le cas contraire, code échouera. Par exemple :

class F {};
class G : public F {};

#include <memory>

using namespace std;

shared_ptr<G> sp0(new G);   // okay, template parameter G and argument G*
shared_ptr<G> sp1(sp0);     // okay, template parameter G and argument shared_ptr<G>
shared_ptr<F> sp2(new G);   // okay, G* convertible to F*
shared_ptr<F> sp3(sp0);     // okay, template parameter F and argument shared_ptr<G>
shared_ptr<F> sp4(sp2);     // okay, template parameter F and argument shared_ptr<F>
shared_ptr<int> sp5(new G); // error, G* not convertible to int*
shared_ptr<int> sp6(sp2);   // error, template parameter int and argument shared_ptr<F>

Un objet shared_ptr possède une ressource :

• s'il a été construit avec un pointeur à cette ressource,

• s'il a été construit à partir d'un objet shared_ptr qui possède cette ressource,

• s'il a été construit à partir d'un objet weak_ptr, classe qui indique cette ressource, ou

• si la propriété de cette ressource lui a été assignée, soit avec shared_ptr::operator= soit en appelant la fonction membre shared_ptr::reset.

Les objets shared_ptr qui possèdent une ressource partagent un bloc de contrôle. Le bloc de contrôle détient:

• le nombre d'objets shared_ptr qui possèdent la ressource,

• le nombre d'objets weak_ptr qui indiquent la ressource,

• la suppression pour cette ressource le cas échéant,

• l'allocateur personnalisé pour le bloc de contrôle le cas échéant.

Un objet shared_ptr qui est initialisé à l'aide d'un pointeur null possède un bloc de contrôle et n'est pas vide. Après qu'un objet shared_ptr libère une ressource, il ne possède plus cette ressource. Après qu'un objet weak_ptr libère une ressource, il ne pointe plus vers cette ressource.

Lorsque le nombre d'objets shared_ptr qui possèdent une ressource devient nul, la ressource est libérée, soit en en la supprimant soit en passant son adresse dans un suppresseur, selon la façon dont la propriété de la ressource fut initialement créée. Lorsque le nombre d'objets shared_ptr qui possèdent une ressource est zéro, et le nombre d'objets weak_ptr qui pointent la ressource est zéro, le bloc de contrôle est relâché, utilisant l'allocateur personnalisé du bloc de contrôle s'il en a un.

Un objet shared_ptr vide ne possède aucune ressource et n'a aucun bloc de contrôle.

Un suppresseur est un objet de fonction qui a une fonction membre operator(). Son type doit être constructible par copie, et le constructeur et le destructeur de la copie ne doivent pas lever d'exceptions. Il accepte un paramètre, l'objet à supprimer.

Certaines fonctions prennent une liste d'arguments qui définit les propriétés de l'object shared_ptr<Ty> ou weak_ptr<Ty> résultant. Vous pouvez spécifier une telle liste d'arguments de plusieurs façons :

aucun argument -- l'objet résultant est un objet vide shared_ptr ou weak_ptr.

ptr -- un pointeur du type Other* doit être managé. Ty doit être un type complet. Si la fonction échoue (car le bloc de contrôle ne peut pas être alloué) il évalue l'expression delete ptr.

ptr, dtor -- un pointeur de type Other* sur la ressource doit être géré et supprimé pour cette ressource. Si la fonction échoue (car le bloc de contrôle ne peut pas être alloué), elle appelle dtor(ptr), qui doit être correctement défini.

ptr, dtor, alloc -- un pointeur de type Other* sur la ressource à gérer, un suppresseur pour cette ressource, et un allocateur pour gérer tout stockage qui doit être alloué et libéré. Si la fonction échoue (car le bloc de contrôle ne peut pas être alloué), elle appelle dtor(ptr), qui doit être correctement défini.

sp -- un objet shared_ptr<Other> qui possède la ressource à gérer.

wp -- un objet weak_ptr<Other> qui pointe sur la ressource à gérer.

ap -- un objet auto_ptr<Other> qui contient un pointeur vers la ressource à gérer. Si la fonction réussit, elle appelle ap.release(); sinon elle laisse ap inchangé.

Dans tous les cas, le type pointeur Other* doit être convertible en type Ty*.

Sécurité des threads

Plusieurs fils peuvent référencer des objets shared_ptr en lecture et en écriture en même temps, même lorsque les objets sont des copies qui partagent la propriété.

Membres

Constructeurs

Méthodes

Opérateurs

Configuration requise

En-tête: <mémoire>

Espace de noms : std

Voir aussi

Référence

weak_ptr, classe

Sécurité des threads dans la bibliothèque standard C++

Autres ressources

<memory> membres