Stack vs Heap di C: Masa Hidup, Dangling Pointer, dan Kapan Memakai Masing-masing

Setiap variabel dalam program C tinggal di suatu tempat, dan tempat itu menentukan dua hal yang tidak bisa kamu ubah setelahnya: berapa lama variabel itu bertahan, dan seberapa banyak yang bisa kamu punya. C memberimu tiga wilayah penyimpanan, dan salah memilih berujung pada crash atau kebocoran memori. Halaman ini menjelaskan ketiganya dan menunjukkan bug klasik yang muncul ketika masa hidup data salah dipahami.

Tiga Wilayah

  high addresses
  +---------------------------+
  |  stack                    |  locals, parameters, return addresses
  |    grows downward  |      |  freed automatically on return
  |                    v      |
  +---------------------------+
  |         (unused gap)      |
  +---------------------------+
  |                    ^      |
  |    grows upward    |      |
  |  heap                     |  malloc / calloc / realloc blocks
  +---------------------------+  freed only by free()
  |  static / global data     |  globals and statics, whole run
  +---------------------------+
  |  code (text)              |  the machine code, read-only
  +---------------------------+
  low addresses

• Penyimpanan otomatis (stack) menampung parameter fungsi dan variabel lokal non-static. Satu blok stack diambil saat fungsi dimasuki dan dilepas saat fungsi kembali. Ukurannya sudah tetap saat kompilasi.
• Penyimpanan dinamis (heap) menampung semua hasil malloc, calloc, dan realloc. Ukurannya ditentukan saat program berjalan, dan masa hidupnya baru berakhir saat free.
• Penyimpanan statis menampung variabel global dan apa pun yang dideklarasikan static. Wilayah ini ada selama program berjalan dan diisi nol sebelum main dimulai.

Alamat pada diagram adalah susunan yang umum, bukan jaminan. Standar C menjelaskan masa hidup, bukan tata letak memori.

Penyimpanan Otomatis dalam Praktik

#include <stdio.h>

void demo(void) {
    int local = 42;             /* created here */
    int table[4] = {1, 2, 3, 4};

    printf("local = %d, table[0] = %d\n", local, table[0]);
}                               /* both released here */

int main(void) {
    demo();
    demo();
    return 0;
}

Setiap pemanggilan demo mendapat local dan table yang baru. Tidak ada yang dibebaskan secara manual, tidak ada yang bisa bocor, dan alokasinya hanya butuh satu instruksi yang menggeser stack pointer. Karena itulah variabel lokal biasa sebaiknya jadi pilihan default: inilah penyimpanan tercepat dan teraman yang dimiliki C.

Masalahnya ada di kurung kurawal penutup. Begitu baris itu dijalankan, memori tersebut hilang.

Dangling Pointer

Ini bug yang pasti pernah ditulis setiap programmer C:

/* BROKEN: returns the address of memory that no longer exists */
int *make_counter(void) {
    int count = 0;
    return &count;          /* count dies at this brace */
}

int main(void) {
    int *p = make_counter();
    *p = 5;                 /* writing into a dead stack frame */
    return 0;
}

&count adalah alamat yang sah selama make_counter berjalan. Saat fungsi kembali, ruang stack itu diserahkan ke fungsi apa pun yang dipanggil berikutnya, sehingga p kini menunjuk ke variabel lokal milik fungsi lain. Membacanya menghasilkan nilai sampah, menulisnya merusak data tersebut. GCC dan Clang memberi peringatan untuk pola persis seperti ini (-Wreturn-local-addr), jadi selalu compile dengan peringatan aktif.

Bug yang sama bisa menyamar lewat array, dan di situ peringatannya sering tidak muncul:

#include <stdio.h>
#include <string.h>

/* Correct: the caller supplies the storage, so it outlives the call. */
void make_greeting(char *out, size_t size, const char *name) {
    snprintf(out, size, "Hello, %s!", name);
}

int main(void) {
    char message[64];
    make_greeting(message, sizeof message, "Ada");
    printf("%s\n", message);
    return 0;
}

Versi rusak dari fungsi itu akan menyusun teksnya di variabel lokal char buf[64] lalu menjalankan return buf;, yaitu mengembalikan alamat buffer yang lenyap pada saat yang sama.

Tiga Cara Memperbaikinya

1. Pemanggil menyediakan buffer (seperti contoh di atas). Tidak ada alokasi, tidak ada pertanyaan soal kepemilikan, dan ini gaya yang paling umum di library C. Fungsinya menerima ukuran buffer supaya tidak menulis melewati batasnya.

2. Kembalikan memori heap, dan jelaskan siapa yang membebaskannya.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/* Returns a newly allocated string; the caller must free it. */
char *make_greeting(const char *name) {
    size_t size = strlen(name) + 16;
    char *out = malloc(size);
    if (out == NULL) {
        return NULL;
    }
    snprintf(out, size, "Hello, %s!", name);
    return out;
}

int main(void) {
    char *message = make_greeting("Ada");
    if (message == NULL) {
        return 1;
    }
    printf("%s\n", message);
    free(message);
    return 0;
}

Blok heap memang dirancang untuk hidup lebih lama daripada fungsinya, dan itulah inti dari memori dinamis. Harganya adalah komentar soal kepemilikan dan free yang harus dipanggil oleh pemanggil.

3. Pakai penyimpanan statis, kalau satu buffer bersama sudah cukup:

#include <stdio.h>

int *next_id(void) {
    static int id = 0;      /* one instance, lives for the whole program */
    id++;
    return &id;             /* safe: static storage never goes away */
}

int main(void) {
    printf("%d\n", *next_id());
    printf("%d\n", *next_id());
    printf("%d\n", *next_id());
    return 0;
}

static di dalam fungsi membuat scope variabel tetap lokal tetapi memberinya masa hidup sepanjang program, jadi mengembalikan alamatnya sah. Konsekuensinya, variabel itu hanya ada satu: semua pemanggil memakainya bersama. Pola ini tidak bisa dipakai di kode multithread, dan tetap bisa mengejutkan di kode single-thread ketika dua pemanggil memegang pointer yang sama pada waktu bersamaan.

Ukuran: Saat Stack Habis

Ruang stack kecil dan tetap. Thread utama biasanya mendapat 1 MB di Windows dan 8 MB di Linux, sedangkan thread yang dibuat belakangan sering mendapat jauh lebih sedikit. Heap dibatasi oleh memori yang tersedia di sistem.

void bad(void) {
    int huge[1000000];      /* ~4 MB of stack - likely crashes on entry */
    huge[0] = 1;
}

Tidak ada pesan diagnostik dan tidak ada NULL yang bisa dicek: program langsung mati, biasanya dengan segmentation fault, sebelum baris pertama di badan fungsi dijalankan. Versi heap melaporkan kegagalan dengan benar:

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    size_t n = 1000000;

    int *huge = malloc(n * sizeof *huge);
    if (huge == NULL) {
        fprintf(stderr, "could not allocate %zu ints\n", n);
        return 1;
    }

    huge[0] = 1;
    huge[n - 1] = 2;
    printf("%d ... %d (%zu bytes)\n", huge[0], huge[n - 1], n * sizeof *huge);

    free(huge);
    return 0;
}

Rekursi yang terlalu dalam juga menghabiskan stack dengan cara yang sama, satu frame demi satu frame. Fungsi rekursif yang tidak berhenti adalah penyebab stack overflow yang paling sering ditemui dalam praktik.

Biaya dan Lokalitas

Alokasi di stack hanyalah satu operasi aritmetika pada sebuah register. Alokasi di heap adalah pemanggilan library yang mencari blok yang cocok, mungkin mengambil lock, dan sesekali meminta memori tambahan dari sistem operasi. Di dalam perulangan yang sering dijalankan, perbedaan itu bisa terukur.

Data di stack juga rapat dan baru saja disentuh, jadi biasanya sudah ada di cache. Blok heap bisa tersebar. Tidak satu pun dari fakta ini boleh menentukan desain sendirian, karena kebenaran masa hidup data harus didahulukan. Tetapi dari dua desain yang sama-sama benar, desain berbasis stack biasanya lebih cepat.

Melihat Wilayah-wilayahnya

Mencetak alamat membuat tata letak ini lebih konkret. Nilai pastinya berbeda setiap kali dijalankan (sistem modern mengacaknya), tetapi pengelompokannya terlihat:

#include <stdio.h>
#include <stdlib.h>

int global_value = 1;

int main(void) {
    static int static_value = 2;
    int local_value = 3;

    int *heap_value = malloc(sizeof *heap_value);
    if (heap_value == NULL) {
        return 1;
    }
    *heap_value = 4;

    printf("global: %p\n", (void *)&global_value);
    printf("static: %p\n", (void *)&static_value);
    printf("heap:   %p\n", (void *)heap_value);
    printf("local:  %p\n", (void *)&local_value);

    free(heap_value);
    return 0;
}

Variabel global dan static letaknya berdekatan, blok heap ada di tempat lain, dan variabel lokal biasanya jauh dari keduanya. Lakukan cast ke void * untuk %p, karena itulah yang diminta format specifier tersebut.

Memilih

Pakai stack jika:

• ukurannya sudah diketahui saat kompilasi,
• datanya hanya dibutuhkan di dalam fungsi ini dan fungsi yang dipanggilnya,
• dan ukurannya kecil, beberapa kilobyte, bukan megabyte.

Pakai heap jika:

• ukurannya bergantung pada input, file, atau hasil perhitungan,
• datanya harus hidup lebih lama daripada fungsi yang membuatnya,
• atau ukurannya cukup besar sampai mengancam batas stack.

Pakai static jika:

• harus ada tepat satu instance selama program berjalan,
• dan memakainya bersama oleh semua pemanggil memang benar.

Pilihan default adalah stack. Gunakan heap jika salah satu dari tiga alasannya berlaku, dan saat kamu melakukannya, ikuti aturan kepemilikan di halaman memory leak supaya blok yang kamu beri masa hidup panjang tetap dibebaskan.

Dua Bug yang Saling Mencerminkan

Keduanya layak disebut bersama, karena keduanya adalah pertanyaan masa hidup yang sama dengan dua jawaban berbeda:

• Dangling pointer: memorinya mati lebih dulu daripada pointernya. Contohnya mengembalikan &local, atau memakai pointer setelah free. Program membaca atau menulis penyimpanan yang kini milik pihak lain.
• Memory leak: pointernya mati lebih dulu daripada memorinya. Contohnya kehilangan referensi terakhir ke blok malloc. Tidak ada yang langsung rusak, prosesnya hanya terus membesar.

Keduanya berasal dari ketidakcocokan antara berapa lama data harus hidup dan wilayah tempat kamu menaruhnya. Tentukan masa hidupnya dulu, wilayahnya akan mengikuti.