weak_ptr
Kelas
Membungkus pointer yang ditautkan dengan lemah.
Sintaks
template<class T> class weak_ptr;
Parameter
T
Jenis yang dikontrol oleh penunjuk lemah.
Keterangan
Templat kelas menjelaskan objek yang menunjuk ke sumber daya yang dikelola oleh satu atau beberapa shared_ptr
objek. Objek weak_ptr
yang menunjuk ke sumber daya tidak memengaruhi jumlah referensi sumber daya. Ketika objek terakhir shared_ptr
yang mengelola sumber daya tersebut dihancurkan, sumber daya akan dibebaskan, bahkan jika ada weak_ptr
objek yang menunjuk ke sumber daya tersebut. Perilaku ini sangat penting untuk menghindari siklus dalam struktur data.
Objek weak_ptr
menunjuk ke sumber daya jika dibuat dari objek yang memiliki shared_ptr
sumber daya tersebut, jika dibangun dari weak_ptr
objek yang menunjuk ke sumber daya tersebut, atau jika sumber daya tersebut ditetapkan untuk itu dengan operator=
. Objek weak_ptr
tidak menyediakan akses langsung ke sumber daya yang diarahkannya. Kode yang perlu menggunakan sumber daya melakukannya melalui objek yang memiliki shared_ptr
sumber daya tersebut, dibuat dengan memanggil fungsi lock
anggota . Objek weak_ptr
telah kedaluwarsa ketika sumber daya yang ditujunya telah dibeberkan karena semua shared_ptr
objek yang memiliki sumber daya telah dihancurkan. Memanggil lock
pada weak_ptr
objek yang telah kedaluwarsa membuat objek kosong shared_ptr
.
Objek kosong weak_ptr
tidak menunjuk ke sumber daya apa pun dan tidak memiliki blok kontrol. Fungsi lock
anggotanya mengembalikan objek kosong shared_ptr
.
Siklus terjadi ketika dua atau beberapa sumber daya yang dikendalikan oleh shared_ptr
objek menyimpan objek yang saling merujuk shared_ptr
. Misalnya, daftar tertaut melingkar dengan tiga elemen memiliki simpul N0
kepala ; simpul itu memegang objek yang memiliki shared_ptr
simpul berikutnya, N1
; simpul itu memegang objek yang memiliki shared_ptr
simpul berikutnya, N2
; simpul itu, pada gilirannya, memegang objek yang memiliki shared_ptr
simpul kepala, N0
, menutup siklus. Dalam situasi ini, jumlah referensi tidak pernah menjadi nol, dan simpul dalam siklus tidak pernah dibeberkan. Untuk menghilangkan siklus, simpul N2
terakhir harus menahan objek yang weak_ptr
menunjuk ke N0
alih-alih shared_ptr
objek. weak_ptr
Karena objek tidak memilikinya N0
tidak memengaruhi N0
jumlah referensi ', dan ketika referensi terakhir program ke simpul kepala dihancurkan simpul dalam daftar juga akan dihancurkan.
Anggota
Nama | Deskripsi |
---|---|
Konstruktor | |
weak_ptr |
Membangun sebuah weak_ptr . |
Penghancur | |
~weak_ptr |
weak_ptr Menghancurkan . |
Typedefs | |
element_type |
Jenis elemen . |
Fungsi anggota | |
expired |
Menguji apakah kepemilikan telah kedaluwarsa. |
lock |
Mendapatkan kepemilikan eksklusif atas sumber daya. |
owner_before |
Mengembalikan true jika ini weak_ptr diurutkan sebelum (atau kurang dari) pointer yang disediakan. |
reset |
Merilis sumber daya yang dimiliki. |
swap |
Tukar dua weak_ptr objek. |
use_count |
Menghitung jumlah shared_ptr objek. |
Operator | |
operator= |
Mengganti sumber daya yang dimiliki. |
element_type
Jenis elemen .
typedef T element_type; // through C++17
using element_type = remove_extent_t<T>; // C++20
Keterangan
Jenisnya adalah sinonim untuk parameter T
templat .
Contoh
// std__memory__weak_ptr_element_type.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>
int main()
{
std::shared_ptr<int> sp0(new int(5));
std::weak_ptr<int> wp0(sp0);
std::weak_ptr<int>::element_type val = *wp0.lock();
std::cout << "*wp0.lock() == " << val << std::endl;
return (0);
}
*wp0.lock() == 5
expired
Menguji apakah kepemilikan telah kedaluwarsa, yaitu, objek yang direferensikan telah dihapus.
bool expired() const noexcept;
Keterangan
Fungsi anggota mengembalikan true
jika *this
telah kedaluwarsa, jika tidak false
.
Contoh
// std__memory__weak_ptr_expired.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>
int main()
{
std::weak_ptr<int> wp;
{
std::shared_ptr<int> sp(new int(10));
wp = sp;
std::cout << "wp.expired() == " << std::boolalpha
<< wp.expired() << std::endl;
std::cout << "*wp.lock() == " << *wp.lock() << std::endl;
}
// check expired after sp is destroyed
std::cout << "wp.expired() == " << std::boolalpha
<< wp.expired() << std::endl;
std::cout << "(bool)wp.lock() == " << std::boolalpha
<< (bool)wp.lock() << std::endl;
return (0);
}
wp.expired() == false
*wp.lock() == 10
wp.expired() == true
(bool)wp.lock() == false
lock
shared_ptr
Mendapatkan yang berbagi kepemilikan sumber daya.
shared_ptr<T> lock() const noexcept;
Keterangan
Fungsi anggota mengembalikan objek kosong shared_ptr
jika *this
telah kedaluwarsa; jika tidak, fungsi tersebut mengembalikan objek yang memiliki shared_ptr<T>
sumber daya yang *this
menunjuk. Mengembalikan nilai yang setara dengan eksekusi atom .expired() ? shared_ptr<T>() : shared_ptr<T>(*this)
Contoh
// std__memory__weak_ptr_lock.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>
int main()
{
std::weak_ptr<int> wp;
{
std::shared_ptr<int> sp(new int(10));
wp = sp;
std::cout << "wp.expired() == " << std::boolalpha
<< wp.expired() << std::endl;
std::cout << "*wp.lock() == " << *wp.lock() << std::endl;
}
// check expired after sp is destroyed
std::cout << "wp.expired() == " << std::boolalpha
<< wp.expired() << std::endl;
std::cout << "(bool)wp.lock() == " << std::boolalpha
<< (bool)wp.lock() << std::endl;
return (0);
}
wp.expired() == false
*wp.lock() == 10
wp.expired() == true
(bool)wp.lock() == false
operator=
Mengganti sumber daya yang dimiliki.
weak_ptr& operator=(const weak_ptr& ptr) noexcept;
template <class Other>
weak_ptr& operator=(const weak_ptr<Other>& ptr) noexcept;
template <class Other>
weak_ptr& operator=(const shared_ptr<Other>& ptr) noexcept;
Parameter
Other
Jenis yang dikontrol oleh argumen bersama atau penunjuk lemah.
ptr
Pointer lemah atau pointer bersama untuk disalin.
Keterangan
Semua operator merilis sumber daya yang saat ini ditunjukkan oleh *this
dan menetapkan kepemilikan sumber daya yang dinamai oleh ptr
ke *this
. Jika operator gagal, operator *this
tidak berubah. Setiap operator memiliki efek yang setara weak_ptr(ptr).swap(*this)
dengan .
Contoh
// std__memory__weak_ptr_operator_as.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>
int main()
{
std::shared_ptr<int> sp0(new int(5));
std::weak_ptr<int> wp0(sp0);
std::cout << "*wp0.lock() == " << *wp0.lock() << std::endl;
std::shared_ptr<int> sp1(new int(10));
wp0 = sp1;
std::cout << "*wp0.lock() == " << *wp0.lock() << std::endl;
std::weak_ptr<int> wp1;
wp1 = wp0;
std::cout << "*wp1.lock() == " << *wp1.lock() << std::endl;
return (0);
}
*wp0.lock() == 5
*wp0.lock() == 10
*wp1.lock() == 10
owner_before
Mengembalikan true
jika ini weak_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
Merilis sumber daya yang dimiliki.
void reset() noexcept;
Keterangan
Fungsi anggota merilis sumber daya yang ditujukkan oleh *this
dan dikonversi *this
ke objek kosong weak_ptr
.
Contoh
// std__memory__weak_ptr_reset.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>
int main()
{
std::shared_ptr<int> sp(new int(5));
std::weak_ptr<int> wp(sp);
std::cout << "*wp.lock() == " << *wp.lock() << std::endl;
std::cout << "wp.expired() == " << std::boolalpha
<< wp.expired() << std::endl;
wp.reset();
std::cout << "wp.expired() == " << std::boolalpha
<< wp.expired() << std::endl;
return (0);
}
*wp.lock() == 5
wp.expired() == false
wp.expired() == true
swap
Tukar dua weak_ptr
objek.
void swap(weak_ptr& wp) noexcept;
Juga termasuk spesialisasi:
template<class T>
void swap(weak_ptr<T>& a, weak_ptr<T>& b) noexcept;
Parameter
wp
Penunjuk lemah untuk ditukar dengan.
Keterangan
swap
Setelah , sumber daya yang awalnya ditujukkan *this
oleh ditujukkan oleh wp
, dan sumber daya yang awalnya ditujukkan wp
oleh ditujukkan ke oleh *this
. Fungsi ini tidak mengubah jumlah referensi untuk dua sumber daya dan tidak melemparkan pengecualian apa pun. Efek dari spesialisasi templat setara dengan a.swap(b)
.
Contoh
// std__memory__weak_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
use_count
Menghitung jumlah shared_ptr
objek yang memiliki sumber daya bersama.
long use_count() const noexcept;
Keterangan
Fungsi anggota mengembalikan jumlah shared_ptr
objek yang memiliki sumber daya yang ditujukkan oleh *this
.
Contoh
// std__memory__weak_ptr_use_count.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>
int main()
{
std::shared_ptr<int> sp1(new int(5));
std::weak_ptr<int> wp(sp1);
std::cout << "wp.use_count() == "
<< wp.use_count() << std::endl;
std::shared_ptr<int> sp2(sp1);
std::cout << "wp.use_count() == "
<< wp.use_count() << std::endl;
return (0);
}
wp.use_count() == 1
wp.use_count() == 2
weak_ptr
Membangun sebuah weak_ptr
.
constexpr weak_ptr() noexcept;
weak_ptr(const weak_ptr& wp) noexcept;
weak_ptr(weak_ptr&& wp) noexcept;
template <class Other>
weak_ptr(const weak_ptr<Other>& wp) noexcept;
template <class Other>
weak_ptr(weak_ptr<Other>&& sp) noexcept;
template <class Other>
weak_ptr(const shared_ptr<Other>& sp) noexcept;
Parameter
Other
Jenis yang dikontrol oleh pointer bersama/lemah argumen. Konstruktor ini tidak berpartisipasi dalam resolusi kelebihan beban kecuali Other*
kompatibel dengan element_type*
.
wp
Pointer lemah untuk disalin.
sp
Penunjuk bersama untuk disalin.
Keterangan
Konstruktor default membuat objek kosong weak_ptr
. Konstruktor yang mengambil argumen setiap membuat objek kosong weak_ptr
jika penunjuk argumen kosong. Jika tidak, mereka membuat weak_ptr
objek yang menunjuk ke sumber daya yang dinamai oleh argumen . Jumlah referensi objek bersama tidak diubah.
Contoh
// std__memory__weak_ptr_construct.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>
int main()
{
std::weak_ptr<int> wp0;
std::cout << "wp0.expired() == " << std::boolalpha
<< wp0.expired() << std::endl;
std::shared_ptr<int> sp1(new int(5));
std::weak_ptr<int> wp1(sp1);
std::cout << "*wp1.lock() == "
<< *wp1.lock() << std::endl;
std::weak_ptr<int> wp2(wp1);
std::cout << "*wp2.lock() == "
<< *wp2.lock() << std::endl;
return (0);
}
wp0.expired() == true
*wp1.lock() == 5
*wp2.lock() == 5
~weak_ptr
weak_ptr
Menghancurkan .
~weak_ptr();
Keterangan
Destruktor menghancurkan ini weak_ptr
tetapi tidak berpengaruh pada jumlah referensi objek tempat pointer tersimpan.