shared_ptr Class

Otacza zliczany według odniesienia inteligentny wskaźnik wokół obiektu przydzielany dynamicznie.

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 kontrolowane przez współdzielonego wskaźnika.

• Other
  Typ kontrolowane przez wskaźnik argument.

• ptr
  Wskaźnik do skopiowania.

• D
  Typ deleter.

• A
  Typ programu przydzielającego.

• dtor
  Delegować.

• alloc
  Program przydzielania.

• sp
  Inteligentne wskaźnik, aby skopiować lub przenieść.

• wp
  Słaby wskaźnik, aby skopiować lub przenieść.

• ap
  Wskaźnik auto, aby skopiować lub przenieść.

• up
  Unikatowy wskaźnik, aby przesunąć.

Uwagi

Klasy opisuje obiekt używający zliczanie do zarządzania zasobami odwołań.A shared_ptr obiekt skutecznie zawiera wskaźnik do zasobu jest właścicielem lub posiada pusty wskaźnik.Zasób może być własnością więcej niż jeden shared_ptr zgłasza zastrzeżeń; podczas ostatniego shared_ptr niszczony jest obiekt, który jest właścicielem określonego zasobu, zasób zostaje zwolniony.

A shared_ptr zatrzymuje, będący właścicielem zasobu jest ponownie przydzielone lub zresetować.

Szablonu na argumencie Ty może być niekompletne typu z wyjątkiem, jak wspomniano w odniesieniu do niektórych funkcji elementów członkowskich.

Gdy shared_ptr<Ty> obiekt składa się z wskaźnikiem zasobu typu G* lub shared_ptr<G>, typ wskaźnika G* musi być konwertowany na Ty*.Jeśli nie jest, kod nie skompiluje się.Na przykład:

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 obiektu jest właścicielem zasobu:

• Jeśli zostało wykonane za pomocą wskaźnika do tego zasobu

• Jeśli zostało wykonane z shared_ptr obiekt, który jest właścicielem tego zasobu

• Jeśli zostało wykonane z weak_ptr Class obiekt, który wskazuje ten zasób, lub

• Jeśli własność tego zasobu przypisano do niego, albo z shared_ptr::operator= lub poprzez wywołanie funkcji składowej shared_ptr::reset.

shared_ptr Obiektów, które są właścicielami zasobu Podziel bloku sterowania.Blok sterowania posiada:

• Liczba shared_ptr obiektów, których właścicielem zasobu,

• Liczba weak_ptr obiektów, które wskazują zasobów,

• deleter dla tego zasobu, jeśli taki istnieje,

• niestandardowego zarządcę w bloku sterowania, jeśli takowa.

A shared_ptr obiekt, który jest inicjowany za pomocą pusty wskaźnik ma blok sterowania i nie jest pusty.Po shared_ptr obiektu uwalnia zasobu, to nie jest już jest właścicielem tego zasobu.Po weak_ptr obiektu uwalnia zasobu, to nie wskazuje już tego zasobu.

Gdy liczba shared_ptr obiektów, że własny zasób wyniesie zero, zasób zostanie zwolniony, usuwając je lub przekazując jej adres do delegować, w zależności od tego, jak własność zasobu został pierwotnie utworzony.Gdy liczba shared_ptr obiektów, które są właścicielami zasobu jest zero, a liczba weak_ptr obiektów, które wskazują że zasób jest zero, blok sterowania zostanie zwolniony, przy użyciu niestandardowego zarządcę w bloku sterowania, jeśli takowa.

Pusta shared_ptr obiekt nie ma żadnych zasobów i ma nie blok sterowania.

Deleter jest obiekt funkcji, która ma funkcję członka operator().Kopiuj skonstruować musi być typu, a jego kopia konstruktora i destruktora musi nie generują wyjątki.Przyjmuje jeden parametr obiektu do usunięcia.

Niektóre funkcje podjąć listy argumentów, który definiuje właściwości wynikowy shared_ptr<Ty> lub weak_ptr<Ty> obiektu.Takie listy argumentów można określić na kilka sposobów:

bez argumentów--wynikowy obiekt, jest shared_ptr obiektu lub pustą weak_ptr obiektu.

ptr--wskaźnikiem typu Other* do zasobu, które mają być zarządzane.Tymusi być typu kompletne.Jeśli funkcja zakończy się niepowodzeniem (ponieważ nie można przydzielić bloku sterowania) daje wynik wyrażenia delete ptr.

ptr, dtor--wskaźnikiem typu Other* do zasobów, które mają być zarządzane i delegować ten zasób.Jeśli funkcja zakończy się niepowodzeniem (ponieważ nie można przydzielić bloku sterowania), wywołuje dtor(ptr), które muszą być dobrze zdefiniowane.

ptr, dtor, alloc--wskaźnikiem typu Other* do zasobów administrowanych, delegować dla danego zasobu i przydzielania do zarządzania żadnej pamięci, która musi być przydziela i zwalnia.Jeśli funkcja zakończy się niepowodzeniem (ponieważ nie można przydzielić bloku sterowania) wywołuje dtor(ptr), które muszą być dobrze zdefiniowane.

sp-- shared_ptr<Other> obiekt, który jest właścicielem zasobu, które mają być zarządzane.

wp-- weak_ptr<Other> obiekt, który wskazuje zasób powinien być zarządzany.

ap-- auto_ptr<Other> obiekt, który przechowuje wskaźnik do zasób powinien być zarządzany.Jeśli funkcja się powiedzie go na wywołania ap.release(); w przeciwnym razie pozostawia ap bez zmian.

We wszystkich przypadkach, typ wskaźnika Other* musi być konwertowany na Ty*.

Bezpieczeństwo wątków

Wiele wątków może odczytywać i zapisywać różne shared_ptr obiekty w tym samym czasie, nawet wtedy, gdy obiekty są kopie, które współużytkują własność.

Elementy członkowskie

Konstruktory

shared_ptr::shared_ptr	Konstrukcje shared_ptr.
shared_ptr::~shared_ptr	Niszczy shared_ptr.

Metody

shared_ptr::element_type	Typ elementu.
shared_ptr::get	Pobiera adres stanowiące własność zasobu.
shared_ptr::owner_before	Zwraca wartość true, jeśli ten shared_ptr porządkowania przed (lub mniej niż) pod warunkiem wskaźnik.
shared_ptr::reset	Zamień właścicielem zasobu.
shared_ptr::swap	Zamienia miejscami dwa shared_ptr obiektów.
shared_ptr::unique	Testy, jeśli właścicielem zasobu jest unikatowy.
shared_ptr::use_count	Zlicza liczby właścicieli zasobów.

Operatory

shared_ptr::operator boolean-type	Sprawdza, czy istnieje stanowiące własność zasobu.
shared_ptr::operator*	Pobiera wartość wyznaczone.
shared_ptr::operator=	Zastępuje stanowiące własność zasobu.
shared_ptr::operator->	Pobiera wskaźnik do wartości wyznaczone.

Wymagania

Nagłówek: <memory>

Obszar nazw: std

Zobacz też

Informacje

weak_ptr Class

Bezpieczeństwo wątków w standardowa biblioteka języka C++

Inne zasoby

<memory> Członkowie