C Academy · Pelajaran

Menghindari Stack Overflow

Batasi rekursi Anda.

Menghindari Stack Overflow adalah pelajaran C Academy gratis di CoddyKit. Ini adalah pelajaran 4 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.

Apa Itu Luapan Tumpukan?

Tumpukan pemanggilan memiliki ukuran terbatas. Setiap pemanggilan fungsi menggunakan sebagian ruangnya untuk parameter dan variabel lokal.

Jika rekursi terlalu dalam, tumpukan akan penuh dan program berhenti dengan luapan tumpukan.

Kasus Dasar Hilang

Penyebab yang paling umum adalah kasus dasar yang tidak pernah tercapai. Hal ini berlangsung tanpa akhir dan menyebabkan tumpukan meluap.

Jangan jalankan fungsi seperti ini; pelajari alasan kegagalannya.

int broken(int n) {
    /* no base case: never stops */
    return broken(n + 1);
}

Argumen Tidak Menyusut

Meskipun memiliki kasus dasar, argumen harus bergerak mendekatinya. Di sini n bertambah, sehingga tidak pernah mencapai 0.

Selalu periksa bahwa setiap pemanggilan semakin mendekati kondisi penghentian.

int oops(int n) {
    if (n == 0) return 0;
    return oops(n + 1); /* wrong direction */
}

Versi yang Benar

Memperbaiki arahnya membuat fungsi berhenti. Sekarang n berkurang menuju kasus dasar 0.

#include <stdio.h>

int good(int n) {
    if (n == 0) return 0;
    return n + good(n - 1);
}

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

Batas Kedalaman Itu Nyata

Bahkan rekursi yang benar dapat menyebabkan luapan jika sangat dalam. Memanggil fungsi hingga jutaan tingkat kedalaman dapat melampaui tumpukan, yang sering kali hanya berukuran beberapa megabita.

Untuk kedalaman yang sangat besar, pilih iterasi.

Mengubah Rekursi Dalam Menjadi Perulangan

Jika kedalaman rekursi bertambah seiring ukuran input, beralihlah ke perulangan. Cara ini menghindari penumpukan ribuan bingkai.

Perulangan di bawah menjumlahkan 1 hingga n yang besar dengan aman menggunakan memori konstan.

#include <stdio.h>

int main(void) {
    long total = 0;
    for (int i = 1; i <= 1000000; i++)
        total += i;
    printf("%ld\n", total);
    return 0;
}

Mengurangi Kedalaman dengan Bagi-dan-Taklukkan

Membagi pekerjaan menjadi dua menjaga kedalaman tetap kecil. Menjumlahkan suatu rentang dengan membaginya menjadi dua membuat kedalaman bertambah seperti logaritma ukuran, bukan secara linear.

long range_sum(int lo, int hi) {
    if (lo == hi) return lo;
    int mid = (lo + hi) / 2;
    return range_sum(lo, mid) + range_sum(mid + 1, hi);
}

Perhatikan Array Lokal yang Besar

Variabel lokal Big membuat setiap bingkai menjadi heavy, sehingga tumpukan lebih cepat penuh.

Hindari mendeklarasikan array besar di dalam fungsi rekursif; teruskan pointer atau gunakan heap sebagai gantinya.

void heavy(int n) {
    int buffer[10000]; /* big frame each call */
    if (n == 0) return;
    heavy(n - 1);
}

Gunakan Akumulator

Meneruskan total berjalan sebagai akumulator membuat setiap bingkai tetap kecil dan membentuk rekursi yang menyerupai rekursi ekor.

Dengan demikian, beberapa kompilator dapat menggunakan kembali satu bingkai.

#include <stdio.h>

long sum_acc(int n, long acc) {
    if (n == 0) return acc;
    return sum_acc(n - 1, acc + n);
}

int main(void) {
    printf("%ld\n", sum_acc(100, 0));
    return 0;
}

Daftar Periksa Keamanan

Sebelum mempercayai fungsi rekursif, periksa:

1. Apakah terdapat kasus dasar?
2. Apakah setiap pemanggilan bergerak mendekatinya?
3. Mungkinkah kedalamannya sangat besar untuk input yang besar?

Jika kedalaman dapat meningkat drastis, gunakan perulangan.

Menguji dengan Input Kecil

Selalu uji rekursi terlebih dahulu dengan input sangat kecil yang dapat Anda verifikasi secara manual.

Jika kasus-kasus kecil berhasil dan kedalamannya tetap terbatas, Anda dapat memperbesar input dengan yakin.

Pemeriksaan Singkat

Temukan perbaikan yang paling aman.

Rangkuman

Luapan tumpukan terjadi ketika rekursi terlalu dalam atau tidak pernah berhenti. Selalu sediakan kasus dasar yang dapat dicapai, kecilkan argumen pada setiap pemanggilan, buat bingkai tetap ringan, dan beralihlah ke iterasi ketika kedalaman dapat bertambah seiring ukuran input.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Menghindari Stack Overflow” gratis?

Ya — teks lengkap “Menghindari Stack Overflow” 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 “Menghindari Stack Overflow”?

Batasi rekursi Anda. 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 4 dari 4.

Berapa lama pelajaran “Menghindari Stack Overflow” 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

← Kembali ke C Academy