0Pricing
C++ Academy · Pelajaran

shared_ptr dan weak_ptr: Kepemilikan Bersama

Bagikan kepemilikan dengan penghitungan referensi dan putus siklus dengan weak_ptr

shared_ptr dan weak_ptr: Kepemilikan Bersama adalah pelajaran C++ Academy gratis di CoddyKit. Ini adalah pelajaran 3 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar C++ Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus C++ Academy mencakup 4 pelajaran total.

Berbagi Objek

Terkadang beberapa bagian program perlu menjaga agar sebuah objek tetap hidup. std::shared_ptr<T> menangani kepemilikan bersama dengan penghitungan referensi.

Membuat shared_ptr

Gunakan std::make_shared—fungsi ini mengalokasikan blok kontrol dan objek dalam satu alokasi.

#include <memory>
auto s = std::make_shared<Widget>(42);
std::cout << s.use_count();   // 1

Penyalinan Membagi Kepemilikan

Menyalin shared_ptr menambah penghitungan referensi. Menghancurkan atau menetapkan ulang akan menguranginya. Saat hitungan mencapai 0, objek dihapus.

auto a = std::make_shared<Widget>();
auto b = a;                  // ref count is now 2
std::cout << a.use_count();  // 2

Cara Kerjanya di Balik Layar

shared_ptr menyimpan dua penunjuk: satu ke objek dan satu ke blok kontrol yang berisi penghitungan referensi. Blok kontrol dialokasikan di memori dinamis.

Penghitungan Referensi Atomik

Penghitungan referensi menggunakan operasi atomik agar shared_ptr dapat disalin dengan aman antarutas. Namun, objek yang ditunjuk itu sendiri tidak otomatis aman untuk digunakan secara bersamaan.

Mengatur Ulang dan Menetapkan Ulang

Menetapkan nilai baru mengurangi penghitungan referensi lama dan menambah penghitungan yang baru. reset() mengosongkan shared_ptr.

shared_ptr dari Penunjuk Mentah (Hindari)

Jangan membuat dua shared_ptr dari penunjuk mentah yang sama — keduanya akan memiliki blok kontrol masing-masing. Selalu gunakan make_shared.

// BUG
Widget* raw = new Widget();
std::shared_ptr<Widget> a(raw);
std::shared_ptr<Widget> b(raw);   // disaster: two control blocks

Masalah Siklus

Dua shared_ptr yang saling merujuk membentuk siklus — penghitung referensi keduanya tidak pernah mencapai nol, sehingga keduanya tidak pernah dibebaskan. Terjadi kebocoran memori.

struct Node {
    std::shared_ptr<Node> next;
};
auto a = std::make_shared<Node>();
auto b = std::make_shared<Node>();
a->next = b;
b->next = a;     // cycle — never freed

Memutus Siklus dengan weak_ptr

std::weak_ptr<T> mengamati shared_ptr tanpa ikut serta dalam penghitung referensi. Gunakan weak_ptr pada salah satu sisi hubungan untuk memutus siklus.

struct Node {
    std::shared_ptr<Node> next;
    std::weak_ptr<Node>  prev;     // weak — does not own
};

Menggunakan weak_ptr

Anda tidak dapat melakukan dereferensi weak_ptr secara langsung. Panggil lock() untuk mendapatkan shared_ptr (atau nilai kosong jika objeknya sudah berakhir).

std::weak_ptr<Widget> w = sharedPtr;
if (auto p = w.lock()) {
    p->use();   // safe — we have a shared_ptr now
} else {
    std::cout << "object expired";
}

Biaya vs unique_ptr

shared_ptr berukuran lebih besar (dua penunjuk + blok kontrol) dan lebih lambat (penghitung referensi atomik). Gunakan hanya jika kepemilikan memang perlu dibagi.

Pemeriksaan Singkat

Apa kasus penggunaan umum untuk std::weak_ptr?

Ringkasan

shared_ptr melacak kepemilikan menggunakan penghitung referensi atomik. Gunakan make_shared, waspadai siklus, dan putuskan siklus tersebut dengan weak_ptr. Pilih unique_ptr jika pembagian kepemilikan tidak diperlukan.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “shared_ptr dan weak_ptr: Kepemilikan Bersama” gratis?

Ya — teks lengkap “shared_ptr dan weak_ptr: Kepemilikan Bersama” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus C++ Academy, upgrade ke CoddyKit PRO. Kursus C++ Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “shared_ptr dan weak_ptr: Kepemilikan Bersama”?

Bagikan kepemilikan dengan penghitungan referensi dan putus siklus dengan weak_ptr Kamu berlatih C++ Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai C++ Academy?

Tidak diperlukan pengalaman sebelumnya. C++ Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 3 dari 4.

Berapa lama pelajaran “shared_ptr dan weak_ptr: Kepemilikan Bersama” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran C++ Academy ini?

Ya. Setiap pelajaran C++ Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

  1. Mengapa Pointer Cerdas Menggantikan new dan delete Mentah
  2. unique_ptr: Kepemilikan Eksklusif
  3. shared_ptr dan weak_ptr: Kepemilikan Bersama
  4. Penghapus Kustom dan Fungsi Make
← Kembali ke C++ Academy