0Pricing
Learn Rust Coding · Pelajaran

Memahami Model Kepemilikan Rust

Pahami aturan inti kepemilikan, semantik pemindahan, dan cara keduanya mencegah galat memori umum seperti pembebasan ganda.

Memahami Model Kepemilikan Rust adalah pelajaran Learn Rust Coding gratis di CoddyKit. Ini adalah pelajaran 1 dari 3. 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 Learn Rust Coding, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Learn Rust Coding mencakup 3 pelajaran total.

Apa Itu Kepemilikan Rust?

Sistem kepemilikan Rust adalah sekumpulan aturan yang mengatur cara program Anda menggunakan memori. Ini merupakan konsep inti yang membantu Rust mencapai keamanan memori tanpa pengumpul sampah.

  • Tidak ada penunjuk yang menggantung.
  • Tidak ada kesalahan pembebasan ganda.
  • Tidak ada perlombaan data dalam kode konkuren.

Rust memeriksa aturan-aturan ini saat kompilasi!

Memori Stack dan Heap

Program menggunakan dua area memori utama: stack dan heap.

  • Stack: Data berukuran tetap yang lebih cepat (seperti bilangan bulat, boolean, dan tipe berukuran diketahui). Data dimasukkan dan dikeluarkan secara berurutan.
  • Heap: Data berukuran variabel yang lebih lambat (seperti String, Vec). Data diminta dan dikembalikan oleh pengalokasi.

Kepemilikan terutama mengatur data di heap, sehingga penggunaannya dan pembersihannya tetap aman.

Aturan 1: Setiap Nilai Memiliki Pemilik

Aturan pertama kepemilikan sederhana: setiap nilai di Rust memiliki sebuah variabel yang disebut pemiliknya.

Bayangkan seperti label pada sebuah kotak. Variabel s di bawah adalah pemilik teks "hello".

fn main() {
  let s = String::from("hello"); // s owns "hello"
  println!("{}", s);
}

Aturan 2: Hanya Satu Pemilik pada Satu Waktu

Aturan kedua menyatakan: pada waktu tertentu, hanya boleh ada satu pemilik untuk sebuah nilai. Hal ini penting untuk mencegah masalah memori.

Saat Anda menetapkan nilai kompleks (seperti String, yang berada di heap) dari satu variabel ke variabel lain, kepemilikan dipindahkan, bukan disalin.

Perpindahan Kepemilikan dalam Praktik

Lihat apa yang terjadi saat nilai s1 ditetapkan ke s2. Cobalah menjalankan kode tersebut.

fn main() {
  let s1 = String::from("Hello, CoddyKit!");
  let s2 = s1; // Ownership of the String data moves from s1 to s2

  // println!("{}", s1); // This line would cause a compile-time error!
  println!("{}", s2);
}

Memahami Semantik "Move"

Setelah let s2 = s1;, s1 tidak lagi dianggap valid. Rust mencegah Anda menggunakan s1 lagi.

  • Ini disebut move. Penunjuk, panjang, dan kapasitas di stack disalin, tetapi data di heap itu sendiri tidak disalin.
  • Jika s1 masih valid, s1 dan s2 akan mencoba membebaskan memori yang sama saat keduanya keluar dari cakupan (sebuah kesalahan pembebasan ganda).

Sistem kepemilikan Rust mencegah hal ini saat kompilasi!

Kepemilikan dan Pemanggilan Fungsi

Meneruskan nilai ke fungsi bekerja seperti menetapkannya ke variabel lain: kepemilikan dipindahkan ke dalam fungsi.

Saat fungsi selesai, pemilik nilai (parameter fungsi) keluar dari cakupan dan nilai tersebut dihapus.

Demonstrasi Kepemilikan Fungsi

Amati bagaimana nilai String dipindahkan ke takes_ownership, lalu gives_ownership mengembalikan String baru.

fn takes_ownership(some_string: String) {
  println!("Inside takes_ownership: {}", some_string);
} // some_string goes out of scope and `drop` is called.

fn gives_ownership() -> String {
  let some_string = String::from("returned string");
  some_string // Ownership is moved out of the function
}

fn main() {
  let s1 = String::from("hello");
  takes_ownership(s1); // s1's value moves into takes_ownership
  // println!("{}", s1); // Error: s1 is no longer valid here!

  let s2 = gives_ownership(); // s2 gets ownership of the returned String
  println!("After gives_ownership: {}", s2);
}

Aturan 3: Cakupan dan Penghapusan

Aturan terakhir: saat pemilik keluar dari cakupan, nilai tersebut akan dihapus.

  • Cakupan adalah rentang dalam program ketika suatu item masih valid, biasanya ditentukan oleh tanda kurung kurawal {}.
  • Saat variabel keluar dari cakupan, Rust secara otomatis memanggil fungsi khusus bernama drop.

Hal ini memastikan memori dibersihkan secara otomatis, aman, dan tanpa pengumpul sampah.

Mencegah Kesalahan Memori

Aturan kepemilikan bekerja bersama untuk menjamin keamanan memori:

  • Satu pemilik: Mencegah beberapa bagian kode Anda mencoba membebaskan memori yang sama.
  • Penghapusan saat cakupan berakhir: Memastikan memori dibebaskan tepat satu kali dan pada waktu yang tepat.

Hal ini menghilangkan bug umum seperti kesalahan pembebasan ganda dan kesalahan penggunaan setelah pembebasan saat kompilasi, sehingga Anda dapat merasa tenang!

Pemeriksaan Kepemilikan

Perhatikan kode Rust berikut. Apa yang akan terjadi saat Anda mencoba mengompilasi dan menjalankannya?

fn main() {
  let message = String::from("Rust is fun!");
  let greeting = message;
  println!("{}", message);
}

Rangkuman: Dasar-Dasar Kepemilikan

Bagus! Anda telah mempelajari aturan dasar sistem kepemilikan Rust:

  • Setiap nilai memiliki pemilik.
  • Hanya boleh ada satu pemilik pada satu waktu.
  • Saat pemilik keluar dari cakupan, nilai tersebut dihapus.

Sistem ini mencegah kesalahan memori umum tanpa pengumpul sampah. Selanjutnya, kita akan mempelajari peminjaman untuk berbagi data tanpa memindahkan kepemilikan.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Memahami Model Kepemilikan Rust” gratis?

Ya — teks lengkap “Memahami Model Kepemilikan Rust” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Learn Rust Coding, upgrade ke CoddyKit PRO. Kursus Learn Rust Coding mencakup 3 pelajaran total.

Apa yang akan aku pelajari di “Memahami Model Kepemilikan Rust”?

Pahami aturan inti kepemilikan, semantik pemindahan, dan cara keduanya mencegah galat memori umum seperti pembebasan ganda. Kamu berlatih Learn Rust Coding 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 Learn Rust Coding?

Tidak diperlukan pengalaman sebelumnya. Learn Rust Coding 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 1 dari 3.

Berapa lama pelajaran “Memahami Model Kepemilikan Rust” 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 Learn Rust Coding ini?

Ya. Setiap pelajaran Learn Rust Coding 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. Memahami Model Kepemilikan Rust
  2. Penjelasan tentang Referensi dan Peminjaman
  3. Masa Hidup untuk Referensi yang Aman
← Kembali ke Learn Rust Coding