`shared_ptr` kelas

Artikel
06/16/2023

Membungkus penunjuk cerdas yang dihitung referensi di sekitar objek yang dialokasikan secara dinamis.

Sintaks

template <class T>
class shared_ptr;

Keterangan

Kelas menjelaskan shared_ptr objek yang menggunakan penghitungan referensi untuk mengelola sumber daya. Objek shared_ptr secara efektif menyimpan pointer ke sumber daya yang dimilikinya atau menyimpan pointer null. Sumber daya dapat dimiliki oleh lebih dari satu shared_ptr objek; ketika objek terakhir shared_ptr yang memiliki sumber daya tertentu dihancurkan, sumber daya dibebaskan.

Berhenti shared_ptr memiliki sumber daya saat ditetapkan ulang atau diatur ulang.

Argumen T templat mungkin merupakan jenis yang tidak lengkap kecuali sebagaimana dicatat untuk fungsi anggota tertentu.

shared_ptr<T> Ketika objek dibangun dari penunjuk sumber daya jenis G* atau dari shared_ptr<G>, jenis G* penunjuk harus dapat dikonversi ke T*. Jika tidak dapat dikonversi, kode tidak akan dikompilasi. Contohnya:

#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>

Objek shared_ptr memiliki sumber daya:

jika dibangun dengan penunjuk ke sumber daya tersebut,
jika dibangun dari objek yang memiliki shared_ptr sumber daya tersebut,
jika dibuat dari weak_ptr objek yang menunjuk ke sumber daya tersebut, atau
jika kepemilikan sumber daya tersebut ditetapkan untuk sumber daya tersebut, baik dengan atau dengan shared_ptr::operator= memanggil fungsi shared_ptr::resetanggota .

Objek shared_ptr yang memiliki sumber daya berbagi blok kontrol. Blok kontrol menahan:

jumlah shared_ptr objek yang memiliki sumber daya,
jumlah weak_ptr objek yang menunjuk ke sumber daya,
penghapusan untuk sumber daya tersebut jika memilikinya,
alokator kustom untuk blok kontrol jika memilikinya.

Objek shared_ptr yang diinisialisasi dengan menggunakan pointer null memiliki blok kontrol dan tidak kosong. Setelah objek shared_ptr merilis sumber daya, objek tersebut tidak lagi memiliki sumber daya tersebut. weak_ptr Setelah objek merilis sumber daya, objek tidak lagi menunjuk ke sumber daya tersebut.

Ketika jumlah shared_ptr objek yang memiliki sumber daya menjadi nol, sumber daya dibesarkan, baik dengan menghapusnya atau dengan meneruskan alamatnya ke penghapus, tergantung pada bagaimana kepemilikan sumber daya awalnya dibuat. Ketika jumlah shared_ptr objek yang memiliki sumber daya adalah nol, dan jumlah weak_ptr objek yang menunjuk ke sumber daya tersebut adalah nol, blok kontrol dibeberkan, menggunakan alokator kustom untuk blok kontrol jika memilikinya.

Objek kosong shared_ptr tidak memiliki sumber daya apa pun dan tidak memiliki blok kontrol.

Deleter adalah objek fungsi yang memiliki fungsi operator()anggota . Jenisnya harus dapat disalin, dan konstruktor dan destruktor salinannya tidak boleh melemparkan pengecualian. Ini menerima satu parameter, objek yang akan dihapus.

Beberapa fungsi mengambil daftar argumen yang menentukan properti dari objek atau weak_ptr<T> yang dihasilkanshared_ptr<T>. Anda dapat menentukan daftar argumen seperti itu dengan beberapa cara:

tidak ada argumen: Objek yang dihasilkan adalah objek kosong shared_ptr atau objek kosong weak_ptr .

ptr: Penunjuk jenis Other* ke sumber daya yang akan dikelola. T harus berupa jenis lengkap. Jika fungsi gagal (karena blok kontrol tidak dapat dialokasikan), fungsi akan mengevaluasi ekspresi delete ptr.

ptr, deleter: Penunjuk jenis Other* ke sumber daya yang akan dikelola dan penghapusan untuk sumber daya tersebut. Jika fungsi gagal (karena blok kontrol tidak dapat dialokasikan), fungsi deleter(ptr)memanggil , yang harus ditentukan dengan baik.

ptr, deleter, alloc: Penunjuk jenis Other* ke sumber daya yang akan dikelola, penghapusan untuk sumber daya tersebut, dan alokator untuk mengelola penyimpanan apa pun yang harus dialokasikan dan dibebaskan. Jika fungsi gagal (karena blok kontrol tidak dapat dialokasikan), fungsi deleter(ptr)memanggil , yang harus ditentukan dengan baik.

sp: Objek shared_ptr<Other> yang memiliki sumber daya yang akan dikelola.

wp: Objek weak_ptr<Other> yang menunjuk ke sumber daya yang akan dikelola.

ap: Objek auto_ptr<Other> yang menyimpan pointer ke sumber daya yang akan dikelola. Jika fungsi berhasil, fungsi akan memanggil ap.release(); jika tidak, fungsi tersebut tidak ap berubah.

Dalam semua kasus, jenis Other* pointer harus dapat dikonversi ke T*.

Keamanan Thread

Beberapa utas dapat membaca dan menulis objek yang berbeda shared_ptr secara bersamaan, bahkan ketika objek disalin yang berbagi kepemilikan.

Anggota

Nama	Deskripsi
Konstruktor
`shared_ptr`	Membangun sebuah `shared_ptr`.
`~shared_ptr`	`shared_ptr`Menghancurkan .
Typedefs
`element_type`	Jenis elemen.
`weak_type`	Jenis penunjuk lemah ke elemen.
Fungsi anggota
`get`	Mendapatkan alamat sumber daya yang dimiliki.
`owner_before`	Mengembalikan true jika ini `shared_ptr` diurutkan sebelum (atau kurang dari) pointer yang disediakan.
`reset`	Ganti sumber daya yang dimiliki.
`swap`	Tukar dua `shared_ptr` objek.
`unique`	Pengujian jika sumber daya yang dimiliki unik.
`use_count`	Menghitung jumlah pemilik sumber daya.
Operator
`operator bool`	Menguji apakah sumber daya yang dimiliki ada.
`operator*`	Mendapatkan nilai yang ditunjuk.
`operator=`	Menggantikan sumber daya yang dimiliki.
`operator->`	Mendapatkan penunjuk ke nilai yang ditunjuk.

`element_type`

Jenis elemen.

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

Keterangan

element_type Jenisnya adalah sinonim untuk parameter Ttemplat .

Contoh

// 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`

Mendapatkan alamat sumber daya yang dimiliki.

element_type* get() const noexcept;

Keterangan

Fungsi anggota mengembalikan alamat sumber daya yang dimiliki. Jika objek tidak memiliki sumber daya, objek akan mengembalikan 0.

Contoh

// 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`

Menguji apakah sumber daya yang dimiliki ada.

explicit operator bool() const noexcept;

Keterangan

Operator mengembalikan nilai ketika trueget() != nullptr, jika tidak false.

Contoh

// 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*`

Mendapatkan nilai yang ditunjuk.

T& operator*() const noexcept;

Keterangan

Operator tidak langsung mengembalikan *get(). Oleh karena itu, pointer yang disimpan tidak boleh null.

Contoh

// 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=`

Menggantikan sumber daya yang dimiliki.

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

Parameter

sp
Penunjuk bersama untuk disalin atau dipindahkan.

ap
Penunjuk otomatis untuk dipindahkan. Kelebihan auto_ptr beban tidak digunakan lagi di C++11 dan dihapus di C++17.

up
Pointer unik ke objek untuk mengadopsi kepemilikan. up tidak memiliki objek setelah panggilan.

Other
Jenis objek yang ditujukkan oleh sp, , apatau up.

Deleter
Jenis penghapusan objek yang dimiliki, disimpan untuk penghapusan objek nanti.

Keterangan

Semua operator mengurangi jumlah referensi untuk sumber daya yang saat ini dimiliki oleh *this dan menetapkan kepemilikan sumber daya yang dinamai menurut urutan operand ke *this. Jika jumlah referensi jatuh ke nol, sumber daya akan dirilis. Jika operator gagal, operator *this tidak berubah.

Contoh

// 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->`

Mendapatkan penunjuk ke nilai yang ditunjuk.

T* operator->() const noexcept;

Keterangan

Operator pilihan mengembalikan get(), sehingga ekspresi sp->member bersifat sama seperti (sp.get())->member di mana sp adalah objek kelas shared_ptr<T>. Oleh karena itu, pointer yang disimpan tidak boleh null, dan T harus merupakan jenis kelas, struktur, atau gabungan dengan anggota member.

Contoh

// 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`

Mengembalikan true jika ini shared_ptr diurutkan sebelum (atau kurang dari) pointer yang disediakan.

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;

Parameter

ptr
Referensi lvalue ke shared_ptr atau weak_ptr.

Keterangan

Fungsi anggota templat mengembalikan true jika *this diurutkan sebelum ptr.

`reset`

Ganti sumber daya yang dimiliki.

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

Parameter

Other
Jenis yang dikontrol oleh penunjuk argumen.

Deleter
Jenis penghapusan.

ptr
Penunjuk untuk disalin.

deleter
Penghapusan yang akan disalin.

Allocator
Jenis alokator.

alloc
Alokator untuk disalin.

Keterangan

Contoh

// 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`

Membangun sebuah shared_ptr.

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;

Parameter

Other
Jenis yang dikontrol oleh penunjuk argumen.

ptr
Penunjuk untuk disalin.

Deleter
Jenis penghapusan.

Allocator
Jenis alokator.

deleter
Penghapusan.

alloc
Alokator.

sp
Penunjuk cerdas untuk disalin.

wp
Penunjuk yang lemah.

ap
Penunjuk otomatis untuk disalin.

Keterangan

Konstruktor masing-masing membuat objek yang memiliki sumber daya yang dinamai oleh urutan operand. Konstruktor shared_ptr(const weak_ptr<Other>& wp) melempar objek pengecualian jenis bad_weak_ptr jika wp.expired().

Contoh

// 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`

shared_ptrMenghancurkan .

~shared_ptr();

Keterangan

Destruktor mengurangi jumlah referensi untuk sumber daya yang saat ini dimiliki oleh *this. Jika jumlah referensi jatuh ke nol, sumber daya akan dirilis.

Contoh

// 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`

Tukar dua shared_ptr objek.

void swap(shared_ptr& sp) noexcept;

Parameter

sp
Penunjuk bersama untuk ditukar.

Keterangan

Fungsi anggota meninggalkan sumber daya yang awalnya dimiliki oleh *this kemudian dimiliki oleh sp, dan sumber daya yang awalnya dimiliki oleh sp kemudian dimiliki oleh *this. Fungsi ini tidak mengubah jumlah referensi untuk dua sumber daya dan tidak melemparkan pengecualian apa pun.

Contoh

// 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`

Pengujian jika sumber daya yang dimiliki unik. Fungsi ini tidak digunakan lagi di C++17, dan dihapus di C++20.

bool unique() const noexcept;

Keterangan

Fungsi anggota mengembalikan true jika tidak ada objek lain shared_ptr yang memiliki sumber daya yang dimiliki oleh *this, jika tidak false.

Contoh

// 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`

Menghitung jumlah pemilik sumber daya.

long use_count() const noexcept;

Keterangan

Fungsi anggota mengembalikan jumlah shared_ptr objek yang memiliki sumber daya yang dimiliki oleh *this.

Contoh

// 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`

Jenis penunjuk lemah ke elemen.

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

Keterangan

Definisi weak_type ditambahkan dalam C++17.

shared_ptr kelas

Sintaks

Keterangan

Keamanan Thread

Anggota

element_type

Keterangan

Contoh

get

Keterangan

Contoh

operator bool

Keterangan

Contoh

operator*

Keterangan

Contoh

operator=

Parameter

Keterangan

Contoh

operator->

Keterangan

Contoh

owner_before

Parameter

Keterangan

reset

Parameter

Keterangan

Contoh

shared_ptr

Parameter

Keterangan

Contoh

~shared_ptr

Keterangan

Contoh

swap

Parameter

Keterangan

Contoh

unique

Keterangan

Contoh

use_count

Keterangan

Contoh

weak_type

Keterangan

Baca juga

Saran dan Komentar

Saran dan Komentar

Sumber Daya Tambahan:

`shared_ptr` kelas

`element_type`

`get`

`operator bool`

`operator*`

`operator=`

`operator->`

`owner_before`

`reset`

`shared_ptr`

`~shared_ptr`

`swap`

`unique`

`use_count`

`weak_type`