#include <stdio.h>

int main() {
    int *ptr = NULL; // Null pointer
    int var = 6;
    *ptr = 6;       // Dereferencing a null pointer causes segmentation fault
    // ptr = &var; //correct
    return 0;
}

/*

What is a Segmentation Fault?
A segmentation fault occurs when a program tries to access a memory location that it is not allowed to access. This often happens when a program tries to:

Read or write memory it does not own.
Access invalid memory addresses, such as dereferencing a NULL or uninitialized pointer.
Exceed memory bounds, such as accessing elements outside the range of an array.
Operating systems enforce memory safety by segmenting memory into different regions (e.g., stack, heap, and code). If a program violates these restrictions, the OS sends a segmentation violation (SIGSEGV) signal, terminating the program.

Common Scenarios Where Segmentation Faults Occur
Dereferencing a NULL Pointer:

A pointer is initialized to NULL but later dereferenced.
c
Copy code
int *ptr = NULL;
*ptr = 10; // Segmentation fault
Using an Uninitialized Pointer:

A pointer is declared but not initialized, and then dereferenced.
c
Copy code
int *ptr;
*ptr = 20; // Undefined behavior, likely segfault
Accessing Memory After Freeing:

Using a pointer after the memory it points to has been freed.
c
Copy code
int *ptr = malloc(sizeof(int));
free(ptr);
*ptr = 30; // Segmentation fault
Out-of-Bounds Array Access:

Accessing an array index that is outside its defined range.
c
Copy code
int arr[5];
arr[10] = 42; // Segmentation fault
Stack Overflow:

Caused by deep or infinite recursion, exhausting the stack memory.
c
Copy code
void recursive_function() {
    recursive_function(); // Infinite recursion
}
Invalid Function Pointers:

Calling a function through an uninitialized or incorrect pointer.
c
Copy code
void (*func_ptr)();
func_ptr(); // Segmentation fault
Accessing Freed or Reallocated Memory:

When accessing memory that has been reallocated or deallocated.
c
Copy code
char *ptr = malloc(10);
free(ptr);
printf("%s\n", ptr); // Segmentation fault
How to Prevent Segmentation Faults
Initialize Pointers:

Always initialize pointers before using them.
c
Copy code
int *ptr = NULL;
Check for NULL Pointers:

Before dereferencing a pointer, check if it is NULL.
c
Copy code
if (ptr != NULL) {
    *ptr = 10;
}
Avoid Dangling Pointers:

After freeing memory, set the pointer to NULL.
c
Copy code
free(ptr);
ptr = NULL;
Validate Array Indexes:

Ensure indices are within bounds when accessing arrays.
c
Copy code
if (index >= 0 && index < ARRAY_SIZE) {
    arr[index] = value;
}
Use Static Analysis Tools:

Tools like valgrind or AddressSanitizer can help detect memory issues during runtime.
Careful Use of Dynamic Memory:

Always check the return value of malloc or calloc.
c
Copy code
int *ptr = malloc(sizeof(int));
if (ptr == NULL) {
    perror("Memory allocation failed");
    exit(1);
}
Avoid Infinite Recursion:

Ensure recursive functions have a base case.
Use Smart Pointers in C++:

In C++, prefer using std::shared_ptr or std::unique_ptr to manage dynamic memory safely.
Debugging Segmentation Faults
To diagnose and fix segmentation faults:

Enable Debug Symbols:

Compile the program with -g to include debug information.
bash
Copy code
gcc -g program.c -o program
Use GDB (GNU Debugger):

Run the program in gdb to pinpoint where the fault occurs.
bash
Copy code
gdb ./program
run
Use Valgrind:

Analyze memory usage and identify invalid accesses.
bash
Copy code
valgrind ./program
Analyze Core Dumps:

Enable core dumps to analyze the program's state at the time of the crash.
bash
Copy code
ulimit -c unlimited
./program
gdb ./program core
By understanding the common causes and following best practices, you can minimize the risk of segmentation faults in your programs.

*/