shared_ptr Class

Article
03/26/2013

Enroule un pointeur intelligent références compté 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 à copier.
D
Le type de suppression.
A
Le type de l'allocateur.
dtor
La suppression.
alloc
L'allocateur.
sp
Le pointeur intelligent à copier ou déplacer.
wp
Le pointeur faible à copier ou déplacer.
ap
Le pointeur automatique à copier ou déplacer.
up
Le seul pointeur à déplacer.

Notes

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

shared_ptr arrête de posséder une ressource lorsque celui-ci est réassigné ou réinitialisation.

L'argument template Ty peut être un type incomplet sauf mention contraire pour certaines fonctions membres.

Lorsqu'un objet d' shared_ptr<Ty> est construit d'un pointeur de ressource de type G* ou d' shared_ptr<G>, le type pointeur G* doit être convertible à Ty*.S'il n'est pas, le code ne pourra pas.Par exemple :

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

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> sp4(new G); // error, G* not convertible to int*
shared_ptr<int> sp5(sp2);   // error, template parameter int and argument shared_ptr<F>

Un objet d' shared_ptr possède une ressource :

s'il a été construit avec un pointeur à cette ressource,
s'il a été construit d'un objet d' shared_ptr qui possède cette ressource,
s'il a été construit d'un objet de weak_ptr Class qui indique cette ressource, ou
si la propriété de cette ressource lui a été assignée, avec shared_ptr::operator= ou en appelant la fonction membre shared_ptr::reset.

Les objets d' shared_ptr que posséder un partage de ressources un bloc de contrôle.Les contient des blocs de contrôle :

le nombre d'objets d' shared_ptr qui possèdent la ressource,
le nombre d'objets d' weak_ptr qui indiquent la ressource,
la suppression de cette ressource cas échéant,
l'allocateur personnalisé pour le bloc de contrôle le cas échéant.

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

Lorsque le nombre d'objets d' shared_ptr que posséder une ressource devient nul, la ressource est relâché, en supprimant ou en passant son adresse à un suppression, selon la façon dont la propriété de la ressource a été initialement créée.Lorsque le nombre d'objets d' shared_ptr que posséder une ressource est zéro, et le nombre d'objets d' weak_ptr qui indiquent cette ressource est zéro, le bloc de contrôle est relâché, à l'aide de l'allocateur personnalisé pour le bloc de contrôle le cas échéant.

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

Un suppression est un objet de fonction qui a une fonction membre operator().Son type doit être copie construtible, et son constructeur de copie et destructeur ne doit pas lever d'exceptions.Elle accepte un paramètre, l'objet à supprimer.

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

pas d'arguments -- l'objet résultant est un objet vide d' shared_ptr ou un objet vide d' weak_ptr .

ptr -- un pointeur de type Other* à la ressource à gérer.Ty doit être un type complet.En cas de échec de fonction (car le bloc de contrôle ne peut pas être alloué) il évalue l'expression delete ptr.

ptr, dtor -- un pointeur de type Other* à la ressource à gérer et de suppression 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* à la ressource à gérer, un suppression pour cette ressource, et un allocateur pour gérer toute mémoire qui doit être allouée et libérée.En cas de échec de fonction (car le bloc de contrôle ne peut pas être alloué) il appelle dtor(ptr), qui doit être correctement défini.

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

wp -- un objet d' weak_ptr<Other> qui indique la ressource à gérer.

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

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

Sécurité des threads

Les threads peuvent objets individuels en lecture et en écriture d' shared_ptr en même temps, même lorsque les objets sont des copies qui partagent la propriété.

Membres

Constructeurs

shared_ptr::shared_ptr	Construit un shared_ptr.
shared_ptr::~shared_ptr	Détruit shared_ptr.

Méthodes

shared_ptr::element_type	Le type d'un élément.
shared_ptr::get	Obtient l'adresse de la ressource propre.
shared_ptr::owner_before	Retourne la valeur true si cet shared_ptr est dimensionné avant (ou inférieur à) le pointeur fournie.
shared_ptr::reset	Ressource propre Repositionne.
shared_ptr::swap	Échange deux objets d' shared_ptr .
shared_ptr::unique	Teste si la ressource est propre seule.
shared_ptr::use_count	Numéros de nombres de propriétaires de ressource.

Opérateurs

shared_ptr::operator boolean-type	Teste si une ressource propre existe.
shared_ptr::operator*	Obtient la valeur indiquée.
shared_ptr::operator=	Remplace la ressource propre.
shared_ptr::operator->	Obtient un pointeur vers la valeur indiquée.

Configuration requise

En-tête : <memory>

L'espace de noms : DST

Voir aussi

Référence

weak_ptr Class

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

Autres ressources

<memory> membres

Partager via