Cara Debugging Segmentation Fault di C/C++

Kalau kamu pernah ngoding C atau C++, pasti sudah tidak asing dengan error legendaris ini: Segmentation Fault. Error ini bisa bikin programmer pusing tujuh keliling karena biasanya program langsung crash tanpa pesan jelas.

Nah, di artikel ini kita akan bahas:

• Apa itu segmentation fault.

• Penyebab umum kenapa error ini muncul.

• Teknik debugging step by step.

• Tools yang bisa dipakai (misalnya gdb, valgrind).

• Tips biar nggak sering kena segmentation fault.

Yuk, kita kulik pelan-pelan dengan gaya santai biar gampang nyangkut di kepala! 

Apa Itu Segmentation Fault?

Segmentation fault (sering disingkat segfault) adalah error yang terjadi ketika program mencoba mengakses memory yang tidak seharusnya.

Coba bayangkan memory komputer itu seperti sebuah gedung apartemen. Program kita cuma boleh masuk ke kamar yang sudah disewa. Kalau tiba-tiba kita nyelonong masuk ke kamar orang lain, ya bakal dimarahi satpam. Nah, “satpam” inilah yang menendang program keluar → hasilnya crash dengan pesan Segmentation fault (core dumped).

Singkatnya:
Segfault = kamu mengakses memory yang ilegal atau tidak valid.

Penyebab Umum Segmentation Fault

Ada beberapa biang kerok klasik yang sering jadi penyebab segfault di C/C++.

1. Akses Pointer yang Tidak Valid

Contoh klasik: pakai pointer tanpa inisialisasi.

#include <stdio.h>

int main() {
    int *ptr; // pointer belum diarahkan ke mana pun
    *ptr = 10; // akses langsung --> Segmentation Fault!
    return 0;
}

Di sini ptr belum mengarah ke alamat memory yang valid, tapi kita nekat memakainya.

2. Akses Array di Luar Batas

Kamu bikin array int arr[5], tapi malah akses arr[10].

#include <stdio.h>

int main() {
    int arr[5] = {1, 2, 3, 4, 5};
    printf("%d\n", arr[10]); // diluar batas --> Segfault
    return 0;
}

3. Free Memory Berkali-kali

Kalau kamu pakai malloc/free di C atau new/delete di C++, hati-hati jangan sampai free dua kali.

#include <stdlib.h>

int main() {
    int *ptr = (int*) malloc(sizeof(int));
    free(ptr);
    free(ptr); // double free --> error atau segfault
    return 0;
}

4. Gunakan Memory Setelah free

Ini disebut dangling pointer.

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

int main() {
    int *ptr = (int*) malloc(sizeof(int));
    *ptr = 42;
    free(ptr);
    printf("%d\n", *ptr); // akses setelah free --> segfault
    return 0;
}

5. Stack Overflow

Misalnya bikin array terlalu besar di stack.

int arr[10000000]; // terlalu besar di stack --> segfault

Cara Debugging Segmentation Fault

Oke, sekarang masuk ke inti artikel. Bagaimana cara kita melacak segfault supaya tahu penyebabnya?

1. Gunakan printf Debugging

Metode klasik: kasih printf di beberapa bagian kode untuk tahu program crash di mana.
Misalnya:

printf("Step 1 OK\n");
printf("Step 2 OK\n");

Kalau program crash sebelum Step 2, berarti masalah ada di antara Step 1 dan Step 2.

Cara ini simpel, tapi lumayan efektif untuk kasus kecil.

2. Gunakan Compiler Warning

Selalu compile dengan opsi warning maksimal.
Misalnya dengan GCC:

gcc -Wall -Wextra -g program.c -o program

-Wall dan -Wextra akan memberi banyak peringatan yang bisa mencegah bug sejak awal.
-g menambahkan informasi debug → berguna nanti di gdb.

3. Debugging dengan gdb

gdb (GNU Debugger) adalah senjata utama programmer C/C++ untuk melacak segfault.

Langkahnya:

1. Compile dengan flag -g:

   gcc -g main.c -o main
   

2. Jalankan dengan gdb:

   gdb ./main
   

3. Di dalam gdb, jalankan program:

   run
   

4. Kalau segfault, ketik:

   backtrace
   

   Ini akan menunjukkan baris kode mana yang menyebabkan crash.

Contoh output:

Program received signal SIGSEGV, Segmentation fault.
0x0000000000401132 in main () at main.c:6
6       *ptr = 10;

Langsung ketahuan bahwa masalah ada di baris *ptr = 10;.

4. Gunakan valgrind

Kalau masalahmu terkait memory (leak, double free, dangling pointer), valgrind sangat membantu.

Contoh:

valgrind ./main

Outputnya bisa seperti:

Invalid write of size 4
   at 0x40053D: main (main.c:6)
 Address 0x0 is not stack'd, malloc'd or (recently) free'd

Jadi langsung ketahuan kalau pointer dipakai dengan tidak benar.

5. Review Kode secara Sistematis

Kadang segfault bukan bug kecil, tapi logic error.
Tips:

• Cek semua pointer: apakah sudah diinisialisasi?

• Cek array: ada kemungkinan out of bounds?

• Cek memory management: ada malloc tanpa free atau free dua kali?

• Cek recursive function: mungkin terlalu dalam sehingga stack overflow.

Tips Mencegah Segmentation Fault

Lebih baik mencegah daripada pusing debugging. Berikut beberapa tips:

1. Selalu inisialisasi pointer ke NULL setelah deklarasi.

2. Setelah free(ptr), langsung set ptr = NULL.

3. Gunakan sizeof saat malloc:

   int *ptr = malloc(10 * sizeof(int));
   

4. Jangan akses array di luar batas → kalau perlu cek dulu panjangnya.

5. Gunakan tools modern: asan (AddressSanitizer), valgrind, gdb.

6. Kalau coding C++ modern, pakai smart pointer (std::unique_ptr, std::shared_ptr) biar lebih aman.

Segmentation fault memang momok bagi programmer C/C++, terutama pemula. Tapi kalau kita paham penyebab umumnya dan tahu cara debugging, sebenarnya error ini bisa dilacak dengan mudah.

Ringkasnya:

• Segfault terjadi karena akses memory ilegal.

• Penyebab umum: pointer tidak valid, array out of bounds, double free, dangling pointer.

• Debugging tools: printf, gdb, valgrind.

• Pencegahan: disiplin memory management, inisialisasi pointer, gunakan smart pointer (di C++).

Jadi, lain kali kalau ketemu pesan Segmentation fault (core dumped), jangan panik dulu. Anggap saja itu alarm kecil bahwa ada yang salah dengan cara kita mengelola memory. Ambil kopi, buka gdb, dan pelan-pelan lacak masalahnya. Dijamin skillmu sebagai programmer C/C++ bakal naik level setelah berhasil menaklukkan segfault.