Segmentation Fault (Core Dumped) – Causes & Fixes

Dereferencing a NULL Pointer

📌 Cause: This happens when a pointer is used before it is properly initialized. Attempting to access memory at address NULL (0x0) will cause a segmentation fault.

❌ Faulty Code:

int *ptr = NULL;
*ptr = 10;  // Segmentation fault

✅ Fix: Always check if the pointer is NULL before dereferencing.

if (ptr != NULL) {
    *ptr = 10;
}

Keywords: NULL pointer dereference, memory access violation, pointer initialization

Buffer Overflow (Out-of-Bounds Access)

📌 Cause: Accessing an array element beyond its allocated bounds can lead to a segmentation fault. This occurs because memory outside the allocated region is accessed, potentially corrupting other variables.

❌ Faulty Code:

int arr[5];
arr[10] = 100;  // Out-of-bounds access

✅ Fix: Always validate the index before accessing the array.

if (index >= 0 && index < 5) {
    arr[index] = 100;
}

Keywords: buffer overflow, out-of-bounds access, array index checking

Using Freed Memory (Dangling Pointer)

📌 Cause: Accessing memory after freeing it leads to undefined behavior and often results in segmentation faults. This is known as a dangling pointer issue.

❌ Faulty Code:

int *ptr = (int *)malloc(sizeof(int));
free(ptr);
printf("%d", *ptr);  // Accessing freed memory

✅ Fix: Set the pointer to NULL after freeing it.

free(ptr);
ptr = NULL;

Keywords: dangling pointer, use-after-free, dynamic memory allocation

Stack Overflow (Infinite Recursion)

📌 Cause: A function that calls itself indefinitely without a base case will cause stack overflow, leading to a segmentation fault.

❌ Faulty Code:

void recurse() { recurse(); }  // No exit condition

✅ Fix: Implement a base condition to stop recursion.

void recurse(int count) {
    if (count == 0) return;
    recurse(count - 1);
}

Keywords: stack overflow, recursive function, infinite recursion

Uninitialized Pointer

📌 Cause: Using a pointer without allocating memory results in undefined behavior and can lead to segmentation faults.

❌ Faulty Code:

int *ptr;
*ptr = 100;  // Uninitialized pointer

✅ Fix: Always allocate memory before using a pointer.

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

Keywords: uninitialized pointer, memory allocation, pointer safety

Modifying String Literal

📌 Cause: String literals are stored in a read-only section of memory. Modifying them leads to a segmentation fault.

❌ Faulty Code:

char *str = "Hello";
str[0] = 'h';  // Segmentation fault

✅ Fix: Use a character array instead of a pointer to modify the string safely.

char str[] = "Hello";
str[0] = 'h';  // Safe modification

Keywords: string literal modification, read-only memory, string handling

gdb ./program
run
backtrace