`shared_ptr` sınıfı

Dinamik olarak tahsis edilen bir nesnenin çevresine bir başvuru sayılan akıllı işaretçi sarar.

Sözdizimi

template <class T>
class shared_ptr;

Açıklamalar

sınıfı shared_ptr , kaynakları yönetmek için başvuru sayma kullanan bir nesneyi açıklar. Nesne shared_ptr , sahip olduğu kaynağa yönelik bir işaretçiyi etkili bir şekilde tutar veya null işaretçi tutar. Bir kaynak birden shared_ptr fazla nesneye ait olabilir; belirli bir kaynağa sahip olan son shared_ptr nesne yok edildiğinde kaynak serbest olur.

yeniden shared_ptr atandığında veya sıfırlandığında kaynağa sahip olmak durdurulur.

Şablon bağımsız değişkeni T , belirli üye işlevleri için belirtilmediği sürece tamamlanmamış bir tür olabilir.

Bir shared_ptr<T> nesne türünden G* veya kaynak işaretçisinden shared_ptr<G>oluşturulduğunda, işaretçi türü G* olarak T*dönüştürülebilir olmalıdır. Dönüştürülebilir değilse kod derlenmez. Örneğin:

#include <memory>
using namespace std;

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> sp5(new G); // error, G* not convertible to int*
shared_ptr<int> sp6(sp2);   // error, template parameter int and argument shared_ptr<F>

Nesne shared_ptr bir kaynağa sahip:

bu kaynağın işaretçisi ile oluşturulduysa,
kaynağın sahibi olan bir shared_ptr nesneden oluşturulduysa,
bu kaynağa işaret eden bir weak_ptr nesneden oluşturulduysa veya
bu kaynağın sahipliği, ile shared_ptr::operator= veya üye işlevi shared_ptr::resetçağrılarak atanmışsa.

Bir shared_ptr kaynağa sahip olan nesneler bir denetim bloğunu paylaşır. Denetim bloğu aşağıdakileri barındırıyor:

kaynağın sahibi olan nesne sayısı shared_ptr ,
kaynağa işaret eden nesne sayısı weak_ptr ,
varsa bu kaynağın silicisi
varsa denetim bloğu için özel ayırıcı.

shared_ptr Null işaretçi kullanılarak başlatılan bir nesnenin denetim bloğu vardır ve boş değildir. Bir shared_ptr nesne bir kaynağı serbest bıraktıktan sonra artık bu kaynağa sahip olmaz. Bir nesne bir weak_ptr kaynağı serbest bıraktığında artık bu kaynağa işaret etmemektedir.

Kaynağın sahibi olan nesne sayısı shared_ptr sıfır olduğunda, kaynağın sahipliğini ilk olarak nasıl oluşturulduğuna bağlı olarak silinerek veya adresini bir siliciye geçirerek kaynak serbest olur. Kaynağın sahibi olan nesne sayısı shared_ptr sıfır olduğunda ve bu kaynağa işaret eden nesne sayısı weak_ptr sıfır olduğunda, denetim bloğu varsa denetim bloğu için özel ayırıcı kullanılarak serbesttir.

Boş shared_ptr bir nesnenin hiçbir kaynağı yoktur ve denetim bloğu yoktur.

Silici, üye işlevi olan bir işlev operator()nesnesidir. Türü kopya oluşturulabilir olmalıdır ve kopya oluşturucu ve yıkıcı özel durumlar oluşturmamalıdır. Silinecek nesne olan bir parametreyi kabul eder.

Bazı işlevler, sonuçta elde shared_ptr<T> edilen veya weak_ptr<T> nesnenin özelliklerini tanımlayan bir bağımsız değişken listesi alır. Böyle bir bağımsız değişken listesini çeşitli yollarla belirtebilirsiniz:

bağımsız değişken yok: Sonuçta elde edilen nesne boş shared_ptr bir nesne veya boş weak_ptr bir nesnedir.

ptr: Yönetilecek kaynağa ilişkin bir Other* işaretçi. T tam bir tür olmalıdır. İşlev başarısız olursa (denetim bloğu ayrılamadığından), ifadesini delete ptrdeğerlendirir.

ptr, deleter: Yönetilecek kaynağa yönelik bir Other* işaretçi ve bu kaynak için bir silici. İşlev başarısız olursa (denetim bloğu ayrılamadığından), iyi tanımlanmış olması gereken öğesini çağırır deleter(ptr).

ptr, deleter, alloc: Yönetilecek kaynağa yönelik bir Other* işaretçi, bu kaynak için bir silici ve ayrılması ve serbest bırakıldı olması gereken depolamayı yönetmek için ayırıcı. İşlev başarısız olursa (denetim bloğu ayrılamadığından), iyi tanımlanmış olması gereken öğesini çağırır deleter(ptr).

spshared_ptr<Other>: Yönetilecek kaynağa sahip olan nesne.

wpweak_ptr<Other>: Yönetilecek kaynağa işaret eden nesne.

apauto_ptr<Other>: Yönetilecek kaynağın işaretçisini tutan nesne. İşlev başarılı olursa çağırır ap.release(); aksi takdirde değişmeden kalır ap .

Her durumda, işaretçi türü Other* olarak T*dönüştürülebilir olmalıdır.

İş Parçacığı Güvenliği

Nesneler sahipliği paylaşan kopyalar olsa bile, birden çok iş parçacığı aynı anda farklı shared_ptr nesneleri okuyabilir ve yazabilir.

Üyeler

Veri Akışı Adı	Açıklama
Oluşturucular
`shared_ptr`	bir `shared_ptr`oluşturur.
`~shared_ptr`	Bir `shared_ptr`yok eder.
Tür tanımları
`element_type`	Öğenin türü.
`weak_type`	Bir öğeye yönelik zayıf işaretçinin türü.
Üye işlevleri
`get`	Sahip olunan kaynağın adresini alır.
`owner_before`	Bu `shared_ptr` , sağlanan işaretçiden önce (veya daha küçük) sıralanmışsa true döndürür.
`reset`	Sahip olunan kaynağı değiştirin.
`swap`	İki `shared_ptr` nesneyi değiştirir.
`unique`	Sahip olunan kaynağın benzersiz olup olmadığını sınar.
`use_count`	Kaynak sahibi sayısını sayar.
İşleçler
`operator bool`	Sahip olunan bir kaynağın mevcut olup olmadığını test eder.
`operator*`	Belirlenen değeri alır.
`operator=`	Sahip olunan kaynağın yerini alır.
`operator->`	Belirlenen değere bir işaretçi alır.

`element_type`

Öğenin türü.

typedef T element_type;                  // before C++17
using element_type = remove_extent_t<T>; // C++17

Açıklamalar

türü element_type , şablon parametresi Tiçin bir eş anlamlıdır.

Örnek

// std__memory__shared_ptr_element_type.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>

int main()
{
    std::shared_ptr<int> sp0(new int(5));
    std::shared_ptr<int>::element_type val = *sp0;

    std::cout << "*sp0 == " << val << std::endl;

    return (0);
}

*sp0 == 5

`get`

Sahip olunan kaynağın adresini alır.

element_type* get() const noexcept;

Açıklamalar

Üye işlevi, sahip olunan kaynağın adresini döndürür. Nesne bir kaynağa sahip değilse 0 döndürür.

Örnek

// std__memory__shared_ptr_get.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>

int main()
{
    std::shared_ptr<int> sp0;
    std::shared_ptr<int> sp1(new int(5));

    std::cout << "sp0.get() == 0 == " << std::boolalpha
        << (sp0.get() == 0) << std::endl;
    std::cout << "*sp1.get() == " << *sp1.get() << std::endl;

    return (0);
}

sp0.get() == 0 == true
*sp1.get() == 5

`operator bool`

Sahip olunan bir kaynağın mevcut olup olmadığını test eder.

explicit operator bool() const noexcept;

Açıklamalar

işleci when get() != nullptrdeğerini true döndürür, aksi takdirde false.

Örnek

// std__memory__shared_ptr_operator_bool.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>

int main()
{
    std::shared_ptr<int> sp0;
    std::shared_ptr<int> sp1(new int(5));

    std::cout << "(bool)sp0 == " << std::boolalpha
        << (bool)sp0 << std::endl;
    std::cout << "(bool)sp1 == " << std::boolalpha
        << (bool)sp1 << std::endl;

    return (0);
}

(bool)sp0 == false
(bool)sp1 == true

`operator*`

Belirlenen değeri alır.

T& operator*() const noexcept;

Açıklamalar

Dolaylı işleci döndürür *get(). Bu nedenle, depolanan işaretçi null olmamalıdır.

Örnek

// std__memory__shared_ptr_operator_st.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>

int main()
{
    std::shared_ptr<int> sp0(new int(5));

    std::cout << "*sp0 == " << *sp0 << std::endl;

    return (0);
}

*sp0 == 5

`operator=`

Sahip olunan kaynağın yerini alır.

shared_ptr& operator=(const shared_ptr& sp) noexcept;

shared_ptr& operator=(shared_ptr&& sp) noexcept;

template <class Other>
shared_ptr& operator=(const shared_ptr<Other>& sp) noexcept;

template <class Other>
shared_ptr& operator=(shared_ptr<Other>&& sp) noexcept;

template <class Other>
shared_ptr& operator=(auto_ptr<Other>&& ap);    // deprecated in C++11, removed in C++17

template <class Other, class Deleter>
shared_ptr& operator=(unique_ptr<Other, Deleter>&& up);

Parametreler

sp
Kopyalanacak veya taşınacak paylaşılan işaretçi.

ap
Taşınacak otomatik işaretçi. Aşırı auto_ptr yükleme C++11'de kullanım dışıdır ve C++17'de kaldırılır.

up
Sahipliğini benimsemek için nesnenin benzersiz işaretçisi. up çağrısından sonra nesneye sahip değildir.

Other
, apveya uptarafından spişaret edilen nesnenin türü.

Deleter
Sahip olunan nesnenin silici türü, nesnenin daha sonra silinmesi için depolanır.

Açıklamalar

İşleçlerin tümü, şu anda sahip olduğu *this kaynağın başvuru sayısını düşürür ve işlenen dizisi tarafından adlandırılan kaynağın sahipliğini olarak *thisatar. Başvuru sayısı sıfıra düşerse kaynak serbest bırakılır. Bir işleç başarısız olursa, değişmeden kalır *this .

Örnek

// std__memory__shared_ptr_operator_as.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>

int main()
{
    std::shared_ptr<int> sp0;
    std::shared_ptr<int> sp1(new int(5));
    std::unique_ptr<int> up(new int(10));

    sp0 = sp1;
    std::cout << "*sp0 == " << *sp0 << std::endl;

    sp0 = up;
    std::cout << "*sp0 == " << *sp0 << std::endl;

    return (0);
}

*sp0 == 5
*sp0 == 10

`operator->`

Belirlenen değere bir işaretçi alır.

T* operator->() const noexcept;

Açıklamalar

Seçim işleci döndürürget(), böylece ifade sp->member sınıfının shared_ptr<T>nesnesi olduğu gibi (sp.get())->member sp davranır. Bu nedenle, depolanan işaretçi null olmamalıdır ve T üyesi memberolan bir sınıf, yapı veya birleşim türü olmalıdır.

Örnek

// std__memory__shared_ptr_operator_ar.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>

typedef std::pair<int, int> Mypair;
int main()
{
    std::shared_ptr<Mypair> sp0(new Mypair(1, 2));

    std::cout << "sp0->first == " << sp0->first << std::endl;
    std::cout << "sp0->second == " << sp0->second << std::endl;

    return (0);
}

sp0->first == 1
sp0->second == 2

`owner_before`

Bu shared_ptr , sağlanan işaretçiden önce (veya daha küçük) sıralanmışsa true döndürür.

template <class Other>
bool owner_before(const shared_ptr<Other>& ptr) const noexcept;

template <class Other>
bool owner_before(const weak_ptr<Other>& ptr) const noexcept;

Parametreler

ptr
veya öğesine yönelik bir shared_ptr weak_ptrlvalue başvurusu.

Açıklamalar

Şablon üyesi işlevi, öncesinde ptrsıralanmışsa *this true döndürür.

`reset`

Sahip olunan kaynağı değiştirin.

void reset() noexcept;

template <class Other>
void reset(Other *ptr);

template <class Other, class Deleter>
void reset(
    Other *ptr,
    Deleter deleter);

template <class Other, class Deleter, class Allocator>
void reset(
    Other *ptr,
    Deleter deleter,
    Allocator alloc);

Parametreler

Other
Bağımsız değişken işaretçisi tarafından denetlenen tür.

Deleter
Silicinin türü.

ptr
Kopyalanacak işaretçi.

deleter
Kopyalanacak silici.

Allocator
Ayırıcının türü.

alloc
Kopyalanacak ayırıcı.

Açıklamalar

Örnek

// std__memory__shared_ptr_reset.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>

struct deleter
{
    void operator()(int *p)
    {
        delete p;
    }
};

int main()
{
    std::shared_ptr<int> sp(new int(5));

    std::cout << "*sp == " << std::boolalpha
        << *sp << std::endl;

    sp.reset();
    std::cout << "(bool)sp == " << std::boolalpha
        << (bool)sp << std::endl;

    sp.reset(new int(10));
    std::cout << "*sp == " << std::boolalpha
        << *sp << std::endl;

    sp.reset(new int(15), deleter());
    std::cout << "*sp == " << std::boolalpha
        << *sp << std::endl;

    return (0);
}

*sp == 5
(bool)sp == false
*sp == 10
*sp == 15

`shared_ptr`

bir shared_ptroluşturur.

constexpr shared_ptr() noexcept;

constexpr shared_ptr(nullptr_t) noexcept : shared_ptr() {}

shared_ptr(const shared_ptr& sp) noexcept;

shared_ptr(shared_ptr&& sp) noexcept;

template <class Other>
explicit shared_ptr(Other* ptr);

template <class Other, class Deleter>
shared_ptr(
    Other* ptr,
    Deleter deleter);

template <class Deleter>
shared_ptr(
    nullptr_t ptr,
    Deleter deleter);

template <class Other, class Deleter, class Allocator>
shared_ptr(
    Other* ptr,
    Deleter deleter,
    Allocator alloc);

template <class Deleter, class Allocator>
shared_ptr(
    nullptr_t ptr,
    Deleter deleter,
    Allocator alloc);

template <class Other>
shared_ptr(
    const shared_ptr<Other>& sp) noexcept;

template <class Other>
explicit shared_ptr(
    const weak_ptr<Other>& wp);

template <class &>
shared_ptr(
    std::auto_ptr<Other>& ap);

template <class &>
shared_ptr(
    std::auto_ptr<Other>&& ap);

template <class Other, class Deleter>
shared_ptr(
    unique_ptr<Other, Deleter>&& up);

template <class Other>
shared_ptr(
    const shared_ptr<Other>& sp,
    element_type* ptr) noexcept;

template <class Other>
shared_ptr(
    shared_ptr<Other>&& sp,
    element_type* ptr) noexcept;

template <class Other, class Deleter>
shared_ptr(
    const unique_ptr<Other, Deleter>& up) = delete;

Parametreler

Other
Bağımsız değişken işaretçisi tarafından denetlenen tür.

ptr
Kopyalanacak işaretçi.

Deleter
Silicinin türü.

Allocator
Ayırıcının türü.

deleter
Silici.

alloc
Ayırıcı.

sp
Kopyalanacak akıllı işaretçi.

wp
Zayıf işaretçi.

ap
Kopyalanacak otomatik işaretçi.

Açıklamalar

Oluşturucuların her biri işlenen dizisi tarafından adlandırılan kaynağa sahip olan bir nesne oluşturur. Oluşturucushared_ptr(const weak_ptr<Other>& wp), ise wp.expired()türünde bad_weak_ptr bir özel durum nesnesi oluşturur.

Örnek

// std__memory__shared_ptr_construct.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>

struct deleter
{
    void operator()(int *p)
    {
        delete p;
    }
};

int main()
{
    std::shared_ptr<int> sp0;
    std::cout << "(bool)sp0 == " << std::boolalpha
        << (bool)sp0 << std::endl;

    std::shared_ptr<int> sp1(new int(5));
    std::cout << "*sp1 == " << *sp1 << std::endl;

    std::shared_ptr<int> sp2(new int(10), deleter());
    std::cout << "*sp2 == " << *sp2 << std::endl;

    std::shared_ptr<int> sp3(sp2);
    std::cout << "*sp3 == " << *sp3 << std::endl;

    std::weak_ptr<int> wp(sp3);
    std::shared_ptr<int> sp4(wp);
    std::cout << "*sp4 == " << *sp4 << std::endl;

    std::auto_ptr<int> ap(new int(15));
    std::shared_ptr<int> sp5(ap);
    std::cout << "*sp5 == " << *sp5 << std::endl;

    return (0);
}

(bool)sp0 == false
*sp1 == 5
*sp2 == 10
*sp3 == 10
*sp4 == 10
*sp5 == 15

`~shared_ptr`

Bir shared_ptryok eder.

~shared_ptr();

Açıklamalar

Yıkıcı, şu anda sahip olduğu kaynağın başvuru sayısını azalmış *thisdurumdadır. Başvuru sayısı sıfıra düşerse kaynak serbest bırakılır.

Örnek

// std__memory__shared_ptr_destroy.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>

int main()
{
    std::shared_ptr<int> sp1(new int(5));
    std::cout << "*sp1 == " << *sp1 << std::endl;
    std::cout << "use count == " << sp1.use_count() << std::endl;

    {
        std::shared_ptr<int> sp2(sp1);
        std::cout << "*sp2 == " << *sp2 << std::endl;
        std::cout << "use count == " << sp1.use_count() << std::endl;
    }

    // check use count after sp2 is destroyed
    std::cout << "use count == " << sp1.use_count() << std::endl;

    return (0);
}

*sp1 == 5
use count == 1
*sp2 == 5
use count == 2
use count == 1

`swap`

İki shared_ptr nesneyi değiştirir.

void swap(shared_ptr& sp) noexcept;

Parametreler

sp
Değiştirebileceğiniz paylaşılan işaretçi.

Açıklamalar

Üye işlevi, başlangıçta daha sonra sahip olduğu *this kaynağı ve daha sonra sp*thissahip olduğu sp kaynağı bırakır. İşlev, iki kaynağın başvuru sayısını değiştirmez ve hiçbir özel durum oluşturmaz.

Örnek

// std__memory__shared_ptr_swap.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>

int main()
{
    std::shared_ptr<int> sp1(new int(5));
    std::shared_ptr<int> sp2(new int(10));
    std::cout << "*sp1 == " << *sp1 << std::endl;

    sp1.swap(sp2);
    std::cout << "*sp1 == " << *sp1 << std::endl;

    swap(sp1, sp2);
    std::cout << "*sp1 == " << *sp1 << std::endl;
    std::cout << std::endl;

    std::weak_ptr<int> wp1(sp1);
    std::weak_ptr<int> wp2(sp2);
    std::cout << "*wp1 == " << *wp1.lock() << std::endl;

    wp1.swap(wp2);
    std::cout << "*wp1 == " << *wp1.lock() << std::endl;

    swap(wp1, wp2);
    std::cout << "*wp1 == " << *wp1.lock() << std::endl;

    return (0);
}

*sp1 == 5
*sp1 == 10
*sp1 == 5
*wp1 == 5
*wp1 == 10
*wp1 == 5

`unique`

Sahip olunan kaynağın benzersiz olup olmadığını sınar. Bu işlev C++17'de kullanım dışı bırakıldı ve C++20'de kaldırıldı.

bool unique() const noexcept;

Açıklamalar

üye işlevi, sahip olduğu kaynağa başka shared_ptr hiçbir nesne sahip *thisfalsedeğilse döndürürtrue.

Örnek

// std__memory__shared_ptr_unique.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>

int main()
{
    std::shared_ptr<int> sp1(new int(5));
    std::cout << "sp1.unique() == " << std::boolalpha
        << sp1.unique() << std::endl;

    std::shared_ptr<int> sp2(sp1);
    std::cout << "sp1.unique() == " << std::boolalpha
        << sp1.unique() << std::endl;

    return (0);
}

sp1.unique() == true
sp1.unique() == false

`use_count`

Kaynak sahibi sayısını sayar.

long use_count() const noexcept;

Açıklamalar

üye işlevi, sahip *thisolduğu kaynağa sahip olan nesne sayısını shared_ptr döndürür.

Örnek

// std__memory__shared_ptr_use_count.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>

int main()
{
    std::shared_ptr<int> sp1(new int(5));
    std::cout << "sp1.use_count() == "
        << sp1.use_count() << std::endl;

    std::shared_ptr<int> sp2(sp1);
    std::cout << "sp1.use_count() == "
        << sp1.use_count() << std::endl;

    return (0);
}

sp1.use_count() == 1
sp1.use_count() == 2

`weak_type`

Bir öğeye yönelik zayıf işaretçinin türü.

using weak_type = weak_ptr<T>; // C++17

Açıklamalar

Tanım weak_type C++17'ye eklendi.

Ayrıca bkz.

Üst Bilgi Dosyaları Başvurusu
<memory>
unique_ptr
weak_ptr sınıfı

Geri Bildirim

Bu sayfayı yararlı buldunuz mu?

Last updated on 2025-11-07

Aracılığıyla paylaş

shared_ptr sınıfı

Sözdizimi

Açıklamalar

İş Parçacığı Güvenliği

Üyeler

element_type

Açıklamalar

Örnek

get

Açıklamalar

Örnek

operator bool

Açıklamalar

Örnek

operator*

Açıklamalar

Örnek

operator=

Parametreler

Açıklamalar

Örnek

operator->

Açıklamalar

Örnek

owner_before

Parametreler

Açıklamalar

reset

Parametreler

Açıklamalar

Örnek

shared_ptr

Parametreler

Açıklamalar

Örnek

~shared_ptr

Açıklamalar

Örnek

swap

Parametreler

Açıklamalar

Örnek

unique

Açıklamalar

Örnek

use_count

Açıklamalar

Örnek

weak_type

Açıklamalar

Ayrıca bkz.

Geri Bildirim

Ek kaynaklar

`shared_ptr` sınıfı

`element_type`

`get`

`operator bool`

`operator*`

`operator=`

`operator->`

`owner_before`

`reset`

`shared_ptr`

`~shared_ptr`

`swap`

`unique`

`use_count`

`weak_type`