shared_ptr – třída

Zabalí inteligentní ukazatel počítaný odkazy do dynamicky alokovaného 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 řízený sdíleným ukazatelem.

• Other
  Typ řízený ukazatelem argumentu.

• ptr
  Ukazatel na kopii.

• D
  Typ odstraňovače.

• A
  Typ alokátoru.

• dtor
  Odstraňovač.

• alloc
  Alokátor.

• sp
  Chytrý ukazatel, který se má zkopírovat nebo přesunout.

• wp
  Slabý ukazatel, který se má zkopírovat nebo přesunout.

• ap
  Automatický ukazatel, který se má zkopírovat nebo přesunout.

• up
  Jedinečný ukazatel na přesunutí.

Poznámky

Třída šablony popisuje objekt, který používá počítání odkazů ke správě prostředků.Objekt shared_ptr účinně drží ukazatel na zdroj, který vlastní, nebo drží ukazatel s hodnotou null.Zdroj může být vlastněn více než jedním objektem shared_ptr; když je poslední objekt shared_ptr, který vlastní určitý prostředek, zničen, prostředek je uvolněn.

shared_ptr přestane vlastnit prostředek, když je znovu přiřazen nebo obnoven.

Argument šablony Ty může být neúplný typ s výjimkou toho, jak je uvedeno pro určité členské funkce.

Když je objekt shared_ptr<Ty> vytvořen z ukazatele na prostředek typu G* nebo z shared_ptr<G>, typ ukazatele G* musí být převeditelný na Ty*.Pokud není, nebude kompilovat kód.Příklad:

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>

Objekt shared_ptr vlastní zdroje:

• pokud byl vytvořen s ukazatelem na tento prostředek,

• pokud byl vytvořen z objektu shared_ptr, který vlastní prostředek,

• pokud byl vytvořen z objektu weak_ptr – třída, který ukazuje na prostředek, nebo

• bylo-li k němu vlastnictví tohoto prostředku přiřazeno, pomocí shared_ptr::operator= nebo voláním členské funkce shared_ptr::reset.

Objekty shared_ptr, které vlastní zdroj, sdílejí řídicí blok.Kontrolní blok obsahuje:

• počet objektů shared_ptr, které zdroj vlastní,

• počet objektů weak_ptr, které na zdroj ukazují,

• odstraňovač pro tento prostředek, pokud existuje,

• vlastní alokátor pro řídicí blok, pokud jej obsahuje.

Objektshared_ptr, který je inicializován pomocí ukazatele null, obsahuje řídicí blok a není prázdný.Poté, co objekt shared_ptr uvolní zdroj, již nevlastní tento zdroj.Poté, co objekt weak_ptr uvolní zdroj, již neukazuje na tento zdroj.

Když počet objektů shared_ptr, které prostředek vlastní, klesne na nulu, zdroj je uvolněn odstraněním nebo předáním jeho adresy deleteru podle toho, jak bylo vlastnictví prostředku původně vytvořeno.Když je počet objektů shared_ptr, které prostředek vlastní, nula a počet objektů weak_ptr, které na tento prostředek odkazují nula, řídicí blok je uvolněn pomocí vlastního alokátoru pro řídicí blok, má-li nějaký.

Prázdný objekt shared_ptr není vlastníkem žádného prostředku a nemá žádný řídicí blok.

Odstraňovač je objekt funkce, který má funkci člena operator().Jeho typ musí mít možnost mít kopírovací konstruktor a kopírovací konstruktor a destruktor musí vyvolávat výjimky.Přijímá jeden parametr, objekt, který se má odstranit.

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

bez argumentů – výsledný objekt je prázdný objekt shared_ptr nebo prázdný objekt weak_ptr.

ptr – ukazatel typu Other* na prostředek, který má být spravován.Ty musí být úplný typ.Pokud selže funkce (protože nelze přidělit řídicí blok), vyhodnotí výraz delete ptr.

ptr, dtor– ukazatel typu Other* na prostředek, který má být spravován, a deleter pro daný prostředek.Pokud funkce selže (protože nelze přidělit řídicí blok), volá dtor(ptr), které musí být dobře definované.

ptr, dtor, alloc– ukazatel typu Other* na prostředek, který má být spravován, deleter pro daný prostředek, a alokátor ke správě úložiště, které musí být přiděleno a uvolněno.Pokud funkce selže (protože nelze přidělit řídicí blok), volá dtor(ptr), které musí být dobře definované.

sp – objekt shared_ptr<Other>, který vlastní prostředek, který se má spravovat.

wp – objekt weak_ptr<Other>, který ukazuje na prostředek, který se má spravovat.

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

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

Zabezpečení vlákna

Více vláken může číst a zapisovat různé objekty shared_ptr ve stejnou dobu, i když jsou objekty kopie, které sdílejí vlastnictví.

Členy

Konstruktory

shared_ptr::shared_ptr	Sestaví shared_ptr.
shared_ptr::~shared_ptr	Zničí shared_ptr.

Metody

shared_ptr::element_type	Typ prvku.
shared_ptr::get	Získá adresu vlastněného prostředku.
shared_ptr::owner_before	Vrátí hodnotu pravda, pokud shared_ptr je řazen před (nebo je menší než) poskytnutý ukazatel.
shared_ptr::reset	Nahradit vlastněný zdroj.
shared_ptr::swap	Prohodí dva objekty shared_ptr.
shared_ptr::unique	Testuje, zda je vlastněný zdroj jedinečný.
shared_ptr::use_count	Počítá vlastníky zdrojů.

Operátory

shared_ptr::operator boolean-type	Testuje, zda existuje vlastněný prostředek.
shared_ptr::operator*	Získá určenou hodnotu.
shared_ptr::operator=	Nahradí vlastněný zdroj.
shared_ptr::operator->	Získá ukazatel na určenou hodnotu.

Požadavky

Záhlaví: <paměť>

Obor názvů: std

Viz také

Referenční dokumentace

weak_ptr – třída

Bezpečný přístup z více vláken ve standardní knihovně C++

Další zdroje

<memory> Členové