Stack vs Heap di Rust (Analogi Meja & Gudang)

Oke, kita langsung gas aja ya ke pembahasannya heheeh 😄

Stack itu seperti meja kerja kecil di depan kamu

Di meja ini, kamu cuma bisa taruh barang kecil dan jumlah terbatas, misalnya catatan, pulpen, atau HP.

Barang di sini cepat diambil karena letaknya dekat dan urutannya jelas: yang terakhir ditaruh, paling atas diambil.

Contohnya di Rust:

let x = 10;

Artinya, Rust taruh angka 10 langsung di “meja” (stack), karena ukurannya kecil dan tetap.

Heap itu seperti gudang besar di belakang rumah

Kalau kamu mau simpan barang besar atau ukurannya gak tentu (kayak sofa, kulkas, atau karung beras), gak mungkin di meja.

Jadi kamu simpan di gudang (heap), dan di meja cuma kamu catat alamat rak-nya di gudang.

Contohnya di Rust:

let s = String::from("Eko");

Artinya:

• “Eko”-nya disimpan di gudang (heap)
• Di meja (stack) cuma ada catatan kecil berisi “lokasi Eko di gudang”

Sekarang kembali ke kode kita!

let mut username: &str = "Eko";
username = "Budi";

Bayangin gini:
"Eko" dan "Budi" itu bukan barang di gudang, tapi poster permanen di dinding kantor (static memory).

&str itu kayak kertas catatan di meja kamu, yang cuma nyatet “lagi ngelihat poster mana”.

Waktu kamu tulis:

username = "Budi";

Rust nggak ganti isi poster, tapi cuma ganti arah pandangan kamu dari poster “Eko” ke poster “Budi”.

Analogi mut di sini

mut artinya kamu boleh mindahin catatan di meja ke arah lain,
tapi nggak boleh ubah isi posternya.

Kalau kamu pengin ubah isi datanya,
kamu butuh String, bukan &str.

Analogi String

String itu kamu cetak posternya sendiri dan simpan di gudang (heap).
Karena kamu yang punya, kamu bebas nulis, hapus, tempel ulang, dll.

let mut username = String::from("Eko");
username.push_str(" Budi");

Sekarang kamu beneran mengubah isi postermu sendiri, bukan cuma ngelihat poster lain.

Nah, Sekarang Kita Masuk ke Konsep String

Kita bahas pake dua lapisan ya —
1️⃣ Analogi “poster di gudang” biar gampang,
2️⃣ Penjelasan real memory behavior biar solid secara teknis.

1. Analogi Dulu: “Poster di Gudang”

Kamu punya variabel:

let mut name = String::from("Budi");

Artinya:

• Kamu cetak poster di gudang bertuliskan “Budi”.

• Di meja (stack) kamu punya catatan:

  • Alamat rak: 1000
  • Panjang: 4 huruf
  • Kapasitas: 4 huruf (karena pas awal, kapasitas = panjang)

Sekarang kamu nulis lagi:

name.push_str(" Anto");

Rust ngecek dulu:

Kapasitas 4 cukup gak buat nambah 5 huruf lagi (“ Anto”)?

Nggak cukup.

Jadi Rust otomatis:

1. Ambil rak baru (lebih besar), misal ukuran 9 huruf.
2. Salin semua isi poster lama (“Budi”) ke rak baru.
3. Tambah tulisan baru (“ Anto”).
4. Buang poster lama dari gudang.

Isi rak baru sekarang:

[B][u][d][i][ ][A][n][t][o]

Catatan di meja:

• Alamat: 2000
• Panjang: 9
• Kapasitas: 9

Jadi jawabannya:
Yang disalin itu isi lama (“Budi”) dan ditambah tulisan baru (“Anto”),
bukan cuma “Anto”-nya aja.

Karena logika push_str = “tambahkan teks di belakang teks lama.”

2. Penjelasan Teknis Real-nya

Setiap String di Rust punya tiga data utama di stack:

ptr → alamat heap tempat data disimpan  
len → berapa banyak karakter saat ini  
capacity → seberapa besar memori yang udah disiapin

Waktu kamu push_str, Rust akan:

1. Cek apakah len + tambahan <= capacity

   • ✅ Kalau cukup → langsung tulis ke heap lama (hemat)

2. Kalau tidak cukup → Rust akan:

   • allocate() heap baru (biasanya kapasitas dikali 2 biar gak sering pindah)
   • copy_from_slice() isi lama (“Budi”)
   • write() tambahan (“ Anto”)
   • free() heap lama

Semua itu dilakukan otomatis, cepat, dan aman (tanpa segfault).

3. Visual Mentalnya

Sebelum:

Heap lama: [B][u][d][i]
cap = 4
len = 4

Sesudah push_str(" Anto"):

Heap baru: [B][u][d][i][ ][A][n][t][o]
cap = 9
len = 9

Heap lama dihapus, tapi isinya disalin dulu.

Insight Tambahan

Kalau kamu lanjut push_str terus (misal tambah “ William”, “ John”),
Rust gak akan alokasi ulang setiap kali.
Dia pakai strategi doubling:

Dari 4 → 8 → 16 → 32 → ...

Supaya gak perlu pindah heap terlalu sering.

Intinya

• Kalau cuma nambah (push_str), Rust copy isi lama + tambahan baru.
• Kalau ganti total (=), Rust hapus isi lama dan buat baru dari nol.