shared_ptr Class

Makale
03/26/2013

Bir başvuru sayılan akıllı işaretçi dinamik olarak atanan bir nesnenin çevresine sarar.

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

Parametreler

Ty
Denetlenen paylaşılan işaretçi türü.
Other
Bağımsız değişken işaretçi kontrol türü.
ptr
Kopyalamak için işaretçi.
D
Deleter türü.
A
Ayırıcı türü.
dtor
Deleter.
alloc
Ayırıcı.
sp
Kopyalamak veya taşımak için akıllı işaretçi.
wp
Kopyalamak veya taşımak için zayıf işaretçi.
ap
Kopyalamak veya taşımak için otomatik işaretçi.
up
Benzersiz işaretçiyi taşımak için.

Notlar

Şablon sınıfı başvuru kaynaklarını yönetmek için sayım kullanan bir nesneyi tanımlar. A shared_ptr nesnesi sahibi veya bir null işaretçi tutan kaynak etkili bir işaretçi tutar. Kaynak birden fazla tarafından sahip olabileceği shared_ptr nesne; zaman son shared_ptr belirli bir kaynağa sahip olan nesne bozulur, kaynağın serbest bırakılır.

A shared_ptr yeniden atanmış veya sıfırlamak, kaynağın sahibi olan durdurur.

Şablon bağımsız değişken Ty dışında tamamlanmamış bir tür üye işlevleri belirli belirtildiği gibi olabilir.

Zaman bir shared_ptr<Ty> nesne türü kaynak işaretçiyle inşa G* veya bir shared_ptr<G>, işaretçi türü G* için dönüştürülebilir olmalıdır Ty*. Değilse, kod derlenmez. Örne?in:

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 bir kaynak nesnenin sahibi:

Bu kaynak için bir işaretçi ile oluşturulur
gelen oluşturulur, bir shared_ptr bu kaynağın sahibi olan nesne
gelen oluşturulur, bir weak_ptr Class , o kaynağa işaret eden nesne veya
Bu kaynak sahipliğini ona ile atanmışsa, shared_ptr::operator= veya üye işlevini çağırarak shared_ptr::reset.

shared_ptr Bir kaynağa sahip nesneler denetim bloğu paylaşın. Denetim bloğu tutar:

sayısı shared_ptr kaynağa sahip nesneler
sayısı weak_ptr , kaynağa işaret eden nesneler
deleter varsa, bu kaynak için
varsa, denetim bloğu için özel ayırıcı.

A shared_ptr bir null işaretçi kullanarak başlatılmış olan nesne denetim bloğu varsa ve boş değil. Sonra bir shared_ptr , artık bu kaynağın sahibi olan nesne bir kaynağı serbest bırakır. Sonra bir weak_ptr nesne bir kaynağı serbest bırakır, artık o kaynağa işaret eder.

Zaman sayısı shared_ptr nesneleri kendi kaynak sıfır olur, kaynak, silmek veya kaynak sahipliğini başlangıçta nasıl oluşturulduğuna bağlı olarak bir deleter adresini geçirerek serbest. Zaman sayısı shared_ptr bir kaynağa sahip nesneler, sıfır ve sayısı weak_ptr nesnelerin üzerine kaynak sıfırsa, denetim bloğu varsa, denetim bloğu özel ayırıcı kullanarak serbest bırakılır.

Boş bir shared_ptr nesnesi herhangi bir kaynağa sahip olmadığından ve hiçbir denetim bloğu vardır.

Bir deleter üye işlevi olan bir işlev nesnesidir operator(). Constructible kopya türü olmalıdır, ve yıkıcı ve kopya oluşturucusuna özel durumlar oluşturması gerekir değil. Silinecek nesnenin bir parametre kabul ettiği.

Bazı işlevler, sonuç özelliklerini tanımlayan bir bağımsız değişken listesi al shared_ptr<Ty> veya weak_ptr<Ty> nesne. Bu tür bir bağımsız değişken listesi çeşitli yollarla belirtebilirsiniz:

hiçbir bağımsız değişken--elde edilen nesne olan boş bir shared_ptr nesne veya boş bir weak_ptr nesne.

ptr--bir işaretçi türü Other* kaynağa yönetilecek. Tytam bir tür olmalıdır. (Denetim bloğu ayrılamıyor çünkü) işlev başarısız olursa ifade değerlendirilir delete ptr.

ptr, dtor--bir işaretçi türü Other* yönetilmesi için kaynak ve bu kaynak için bir deleter. (Denetim bloğu ayrılamıyor çünkü) işlev başarısız olursa, onu çağıran dtor(ptr), hangi olmalıdır iyi tanımlanmış.

ptr, dtor, alloc--bir işaretçi türü Other* yönetilmesi için kaynak, bu kaynak ve tahsis edilen ve serbest gerekir herhangi bir depolama yönetmek için bir ayırıcı için bir deleter. (Denetim bloğu ayrılamıyor çünkü) işlev başarısız olursa çağırır dtor(ptr), hangi olmalıdır iyi tanımlanmış.

sp--bir shared_ptr<Other> yönetilecek kaynağın sahibi olan nesne.

wp--bir weak_ptr<Other> yönetilmek üzere kaynak gösteren nesne.

ap--bir auto_ptr<Other> yönetilmek üzere kaynak için bir işaretçi tutan nesne. İşlev çağrılarının başarılı olursa ap.release(); Aksi durumda bırakır ap değişmez.

Tüm durumlarda, işaretçi türü Other* için dönüştürülebilir olmalıdır Ty*.

İş parçacığı güvenliği

Birden çok iş parçacığı okuma ve yazma farklı shared_ptr nesneleri aynı anda bile nesnelerin sahipliği paylaşan kopyalarıdır.

Üyeler

Oluşturucular

shared_ptr::shared_ptr	Oluşturan bir shared_ptr.
shared_ptr::~shared_ptr	Yok eder bir shared_ptr.

Yöntemler

shared_ptr::element_type	Öğenin türü.
shared_ptr::get	Sahip olunan kaynak adresi alır.
shared_ptr::owner_before	Bu ise doğru döndürür shared_ptr önce sipariş (veya az) sağlanan işaretçi.
shared_ptr::reset	Kaynak sahibi Değiştir.
shared_ptr::swap	İki değiştirir shared_ptr nesneler.
shared_ptr::unique	Sahip olunan kaynağın benzersiz sağlayıp sağlamadığını test eder.
shared_ptr::use_count	Kaynak sahiplerine sayısını sayar.

İşleçler

shared_ptr::operator boolean-type	Sahip olunan bir kaynak var sağlayıp sağlamadığını test eder.
shared_ptr::operator*	Belirlenen değeri alır.
shared_ptr::operator=	Sahip olunan kaynağın yerini alır.
shared_ptr::operator->	Belirtilen değer için bir işaretçi alır.

Gereksinimler

Başlık: <memory>

Ad alanı: std

Ayrıca bkz.

Başvuru

weak_ptr Class

Standart C++ Kitaplığı'nda iş parçacığı güvenliği

Diğer Kaynaklar

<memory> Üyeler

Aracılığıyla paylaş