0Pricing
C++ Academy · Pelajaran

unique_ptr: Kepemilikan Eksklusif

Nyatakan semantik satu pemilik dengan unique_ptr dan tipe yang hanya dapat dipindahkan

unique_ptr: Kepemilikan Eksklusif adalah pelajaran C++ Academy gratis di CoddyKit. Ini adalah pelajaran 2 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.

Penunjuk Cerdas dengan Satu Pemilik

std::unique_ptr<T> memiliki satu objek di memori dinamis. Saat unique_ptr dihancurkan, objek tersebut dihapus. unique_ptr tidak dapat disalin—hanya dapat dipindahkan.

Membuat unique_ptr

Gunakan std::make_unique (C++14)—aman terhadap pengecualian dan ringkas.

#include <memory>
auto w = std::make_unique<Widget>();         // default-constructed
auto p = std::make_unique<Point>(3, 4);       // forwarded args

Menggunakannya Seperti Penunjuk

unique_ptr mendukung operasi penunjuk yang umum.

auto p = std::make_unique<Point>(3, 4);
std::cout << p->x;        // arrow access
std::cout << (*p).y;      // dereference
if (p) std::cout << "non-null";

Tidak Dapat Menyalin—Dapat Memindahkan

Penyalinan akan berarti ada dua pemilik—hal itu melanggar makna "unik." Pemindahan mengalihkan kepemilikan.

std::unique_ptr<int> a = std::make_unique<int>(1);
std::unique_ptr<int> b = std::move(a);
// a is now empty, b owns the int

Meneruskannya ke Fungsi

Berdasarkan nilai (dengan std::move): alihkan kepemilikan. Berdasarkan referensi: pinjam tanpa memiliki.

void consume(std::unique_ptr<Widget> w);   // takes ownership
void inspect(const Widget& w);              // borrows

auto w = std::make_unique<Widget>();
consume(std::move(w));
// w is now empty
inspect(*w);                                // (after re-creating)

Mengembalikannya dari Fungsi

Fungsi yang mengalokasikan objek dan mengembalikan kepemilikannya sebaiknya mengembalikan std::unique_ptr.

std::unique_ptr<Widget> create() {
    return std::make_unique<Widget>();
}

Mengatur Ulang dan Melepaskan

reset() menghapus objek saat ini dan (secara opsional) mengambil kepemilikan objek baru. release() melepaskan kepemilikan dan mengembalikan penunjuk mentah.

auto p = std::make_unique<int>(10);
p.reset(new int(20));    // delete the old, own the new
int* raw = p.release();   // p is now empty
delete raw;               // caller must delete

get(): Meminjam Penunjuk Mentah

get() mengembalikan penunjuk mentah tanpa melepaskan kepemilikan. Gunakan untuk interoperabilitas tanpa kepemilikan.

auto p = std::make_unique<int>(42);
legacy_api(p.get());      // p still owns it

unique_ptr untuk Larik

Untuk larik, gunakan unique_ptr<T[]>. Akses menggunakan indeks dengan []; delete[] dipanggil saat objek dihancurkan.

auto arr = std::make_unique<int[]>(10);
arr[0] = 99;
std::cout << arr[0];

Penghapus Khusus

Sediakan penghapus khusus sebagai parameter templat ketika sumber dayanya bukan memori mentah (penangan berkas, sumber daya OS).

auto closer = [](FILE* f) { if (f) std::fclose(f); };
std::unique_ptr<FILE, decltype(closer)> file(std::fopen("a.txt","r"), closer);

Performa

Dengan penghapus bawaan, unique_ptr memiliki ukuran dan kecepatan yang sama seperti penunjuk mentah—tanpa overhead.

Pemeriksaan Singkat

Mengapa std::unique_ptr melarang penyalinan?

Ringkasan

std::unique_ptr adalah penunjuk cerdas bawaan: tanpa overhead, memiliki kepemilikan eksklusif, dapat dipindahkan tetapi tidak dapat disalin. Lebih baik gunakan std::make_unique untuk konstruksi.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “unique_ptr: Kepemilikan Eksklusif” gratis?

Ya — teks lengkap “unique_ptr: Kepemilikan Eksklusif” 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 “unique_ptr: Kepemilikan Eksklusif”?

Nyatakan semantik satu pemilik dengan unique_ptr dan tipe yang hanya dapat dipindahkan 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 2 dari 4.

Berapa lama pelajaran “unique_ptr: Kepemilikan Eksklusif” 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