shared_ptr Class

Článek
03/26/2013

Obtéká počítáno odkaz inteligentní ukazatel kolem dynamicky přiřazené objektu.

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);
};

Parametry

Ty
Typ řízena sdílený ukazatel.
Other
Typ řízena argument ukazatele.
ptr
Ukazatel kopírování.
D
Typ deleter.
A
Typ přidělujícího modulu.
dtor
Deleter.
alloc
Přidělování.
sp
Inteligentní ukazatel zkopírovat nebo přesunout.
wp
Slabé ukazatel zkopírovat nebo přesunout.
ap
Ukazatel automaticky zkopírovat nebo přesunout.
up
Jedinečný ukazatel přesunutí.

Poznámky

Třída šablony popisuje objekt, který používá odkaz počítání ke správě prostředků.A shared_ptr objekt účinně obsahuje ukazatel na prostředek, vlastní nebo drží ukazatel s hodnotou null.Prostředek může být vlastněn více než jeden shared_ptr objekt; Při poslední shared_ptr objekt, který vlastní prostředek zejména zničen, uvolnění prostředku.

A shared_ptr přestane vlastnící zdroj je přiřazen nebo obnovit.

Šablonu argumentu Ty mohou být neúplné typu s výjimkou, jak je uvedeno pro určité členské funkce.

Při shared_ptr<Ty> objektu je vyroben z prostředku ukazatele typu G* nebo shared_ptr<G>, typ ukazatele G* musí být převoditelný na Ty*.Pokud není, nebude kód zkompilován.Příklad:

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>

A shared_ptr objekt, který vlastní prostředek:

Pokud byl vytvořen pomocí ukazatele na daný prostředek
Pokud byl vytvořen z shared_ptr objekt, který je vlastníkem prostředku,
Pokud byl vytvořen z weak_ptr Class objekt, který odkazuje na tento zdroj, nebo
je-li vlastnictví prostředku byla přiřazena, buď s shared_ptr::operator= nebo voláním členské funkce shared_ptr::reset.

shared_ptr Objekty, které vlastní zdroj sdílet řídicí blok.Řídicí blok obsahuje:

počet shared_ptr objekty, které vlastní zdroje,
počet weak_ptr objekty, které vedou k prostředku,
deleter pro daný prostředek, pokud existuje,
vlastním přidělováním pro řídicí blok, pokud existuje.

A shared_ptr objekt, který je inicializována pomocí nulový ukazatel má řídicí blok a není prázdný.Po shared_ptr objekt uvolní prostředek, již vlastní tento prostředek.Po weak_ptr objekt uvolní prostředek, již odkazuje k danému prostředku.

Pokud počet shared_ptr objekty vlastní zdroj bude roven nule, že zdroj je uvolněno, odstraněním nebo předáním adresy deleter, v závislosti na tom, jak byla původně vytvořena vlastnictví prostředku.Pokud počet shared_ptr objekty, které vlastní zdroje je nula a počet weak_ptr objekty, které ukazují, že prostředek je nula, uvolněno řídicí blok pomocí vlastním přidělováním pro řídicí blok, pokud existuje.

Prázdné shared_ptr objekt nevlastní žádné prostředky a má žádné řídicí blok.

Deleter je funkce objektu, který má členská funkce operator().Kopírovat constructible musí být typu a jeho kopie konstruktoru a destruktoru musí vyvolat výjimky.Přijímá jeden parametr objektu, který chcete odstranit.

Některé funkce přijmout seznam argumentů, které definuje vlastnosti výsledné shared_ptr<Ty> nebo weak_ptr<Ty> objektu.Takový seznam argumentů můžete zadat několika způsoby:

žádný argument – výsledný objekt je prázdný shared_ptr objekt nebo prázdné weak_ptr objektu.

ptr--ukazatele typu Other* prostředek pro správu.Tymusí být kompletní typu.Je-li funkce se nezdaří (protože řídicí blok nelze přidělit) vyhodnotí výraz delete ptr.

ptr, dtor--ukazatele typu Other* prostředek pro správu a deleter pro daný prostředek.Je-li funkce se nezdaří (protože nelze přidělit řídicí blok), volá dtor(ptr), které musí být dobře definovaný.

ptr, dtor, alloc--ukazatele typu Other* prostředků spravovaných, deleter pro daný prostředek a přidělování správy úložiště musí být a uvolnit.Pokud funkce se nezdaří (protože nelze přidělit řídicí blok) volá dtor(ptr), které musí být dobře definovaný.

sp-- shared_ptr<Other> objekt, který vlastní prostředek pro správu.

wp-- weak_ptr<Other> objekt, který odkazuje na prostředek, který chcete spravovat.

ap-- auto_ptr<Other> objekt, který obsahuje ukazatel na prostředek pro správu.Je-li funkce úspěšné volání ap.release(); v opačném případě zůstane ap beze změny.

Ve všech případech ukazatele typu Other* musí být převoditelný na Ty*.

Zabezpečení vlákna

Více vláken může číst a zapisovat různé shared_ptr objektů současně, i když se objekty jsou kopie, které sdílejí vlastnictví.

Členy

Konstruktory

shared_ptr::shared_ptr	Konstrukce shared_ptr.
shared_ptr::~shared_ptr	Ničí shared_ptr.

Metody

shared_ptr::element_type	Typ elementu.
shared_ptr::get	Adresu získá vlastnictví prostředků
shared_ptr::owner_before	Vrátí hodnotu PRAVDA, pokud tato shared_ptr je řazen před (nebo menší než) poskytnutý ukazatel.
shared_ptr::reset	Nahraďte zdroj vlastnictví.
shared_ptr::swap	Zamění dva shared_ptr objekty.
shared_ptr::unique	Zkoušky, je-li vlastnictví prostředků je jedinečný.
shared_ptr::use_count	Počet čísel vlastníků prostředku.

Operátory

shared_ptr::operator boolean-type	Zkoušky, pokud existuje vlastnictví prostředků.
shared_ptr::operator*	Získá určenou hodnotu.
shared_ptr::operator=	Nahrazuje vlastnictví prostředků.
shared_ptr::operator->	Získá ukazatel na určenou hodnotu.

Požadavky

Záhlaví: <memory>

Obor názvů: std

Viz také

Referenční dokumentace

weak_ptr Class

Bezpečnostní vlákno v Standardní knihovna C++

Další zdroje

<memory> Členové

Sdílet prostřednictvím