shared_ptr — Klasa
Otacza inteligentny wskaźnik zliczonych odwołań wokół obiektu przydzielanego 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 kontrolowany przez dzielony wskaźnik.Other
Typ kontrolowany przez wskaźnik argumentu.ptr
Wskaźnik do skopiowania.D
Typ deletera.A
Typ alokatora.dtor
Deleter.alloc
Alokator.sp
Inteligentny 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
Klasa szablonu opisuje obiekt używający odwołania, który liczy zarządzanie zasobami.Obiekt shared_ptr skutecznie mieści wskaźnik do zasobu, który posiada lub mieści wskaźnik typu null.Zasób może być własnością więcej niż jednego obiektu shared_ptr; podczas niszczenia ostatniego obiektu shared_ptr, który posiada określony zasób, zasób zostanie zwolniony.
shared_ptr zatrzymuje posiadanie zasobu gdy jest ponownie przypisany lub zresetowany.
Argument szablonu Ty może być niekompletnym typem wyjątku jak wspomniano dla niektórych funkcji elementów członkowskich.
Gdy shared_ptr<Ty> obiekt jest wykonany z zasobu wskaźnika typu G* lub z shared_ptr<G>, typu wskaźnika G* musi być konwertowany na Ty*.Jeśli tak nie jest, kod nie zostanie skompilowany.Na przykład:
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>
Obiekt shared_ptr posiada zasób:
jeśli został wykonany ze wskaźnikiem do tego zasobu,
jeśli został zbudowany z obiektu shared_ptr, który jest właścicielem tego zasobu,
jeśli został zbudowany z obiektu weak_ptr — Klasa, który wskazuje ten zasób, lub
jeśli własność tego zasobu została przydzielona do niego z shared_ptr::operator= lub przez wywołanie funkcji członkowskiej shared_ptr::reset.
shared_ptr obiekty, które są właścicielami zasobu dzielą się blokiem kontroli.Blok sterowania posiada:
Liczba shared_ptr obiektów, które są właścicielami zasobu,
Liczba weak_ptr obiektów, które wskazują na zasoby
deleter dla tego zasobu, jeśli taki istnieje,
niestandardowy alokator bloku kontroli, jeśli taki istnieje.
Obiekt shared_ptr, który jest inicjowany użyciem wskaźnika typu null posiada blok sterowania i nie jest pusty.Po uwolnieniu zasobu przez obiekt shared_ptr, nie jest już właścicielem tego zasobu.Po uwolnieniu zasobu przez obiekt weak_ptr, nie wskazuje już tego zasobu.
Gdy liczba shared_ptr obiektów, które posiadają zasoby wyniesie zero, zasób zostanie zwolniony poprzez usunięcie lub przekazanie jego adresu do modułu usuwającego, w zależności od tego, jak została utworzona własność zasobu.Gdy liczba shared_ptr obiektów, które są właścicielami zasobu wynosi zero, a liczba weak_ptr liczba obiektów, które wskazują na ten zasób wynosi zero, blok kontroli zostanie zwolniony, za pomocą niestandardowego zarządcy dla bloku sterowania, jeśli ma taki.
Pusty obiekt shared_ptr nie posiada żadnych zasobów i ma nie bloku sterowania.
Deleter jest obiektem funkcji, który posiada funkcję członkowską operator().Jego typ musi być kopią konstrukcyjną, a konstruktor kopiujący i destruktor nie mogą wyrzucać wyjątków.Przyjmuje jeden parametr, obiekt do usunięcia.
Niektóre funkcje podejmują listy argumentów, który definiują właściwości wynikające z shared_ptr<Ty> lub weak_ptr<Ty> obiektu.Można określić taką listę argumentów na kilka sposobów:
bez argumentów -- wynikowy obiekt jest pustym obiektem shared_ptr lub pustym obiektem weak_ptr.
ptr--wskaźnika typu Other* do zasobów do zarządzania.Ty wymagany jest kompletny typ.Jeśli funkcja zawiedzie (ponieważ nie można przydzielić bloku sterowania), ocenia wyrażenie delete ptr.
ptr, dtor--wskaźnika typu Other* do zasobów zarządzanych i deleter dla tego zasobu.Jeśli funkcja zawiedzie (ponieważ nie można przydzielić bloku sterowania), wywołuje dtor(ptr), które musi być dobrze zdefiniowane.
ptr, dtor, alloc--wskaźnika typu Other* do zasobów administrowanych, deleter dla tego zasobu i przydzielania do zarządzania magazynu musi być przydzielny i wolny.Jeśli funkcja zawiedzie (ponieważ nie można przydzielić bloku sterowania), wywołuje dtor(ptr), które musi być dobrze zdefiniowane.
sp -- shared_ptr<Other> obiekt, który posiada zasoby do zarządzania.
wp-- weak_ptr<Other> obiektu, który wskazuje na zasoby do zarządzania.
obiekt ap -- an auto_ptr<Other>, który posiada wskaźnik do zasobu do zarządzania.Jeśli funkcja się powiedzie, wywołuje ap.release(); w przeciwnym razie pozostawia ap bez zmian.
We wszystkich przypadkach, typ wskaźnika Other* musi być konwertowany na Ty*.
Bezpieczeństwo wątku
Wiele wątków może odczytywać i zapisywać różne obiekty shared_ptr w tym samym czasie, nawet wtedy, gdy obiekty są kopiami, które dzielą prawo własności.
Elementy członkowskie
Konstruktorów
Tworzy shared_ptr. |
|
Niszczy shared_ptr. |
Metody
Typ elementu. |
|
Pobiera adres stanowiących własność zasobów. |
|
Zwraca wartość true, jeśli ten shared_ptr był zamówiony przed (lub mniej niż) podany wskaźnik. |
|
Zamień posiadane zasoby. |
|
Zamień dwa shared_ptr obiekty. |
|
Testuje, czy posiadane zasoby są unikatowe. |
|
Zlicza liczby właścicieli zasobu. |
Operatory
Sprawdza, czy istnieją własne zasoby. |
|
Pobiera wartość wyznaczoną. |
|
Zamienia posiadane zasoby. |
|
Pobiera wskaźnik do wyznaczonej wartości. |
Wymagania
Nagłówek: <pamięć>
Przestrzeń nazw: std
Zobacz też
Informacje
Bezpieczeństwo wątku w standardowej bibliotece C++