Segmentation Fault in C++

Segmentation faults C++ is an error that occurs when a program attempts to access a memory location it does not have permission to access. Generally, this error occurs when memory access is violated and is a type of general protection fault. Segfaults are the abbreviation for segmentation faults.

Causes of Segmentation Fault in C++

A program has access to specific regions of memory while it is running. First, the stack is used to hold the local variables for each function. Moreover, it might have memory allocated at runtime and saved on the heap (new in C++ and you may also hear it called the “free store“). The only memory that the program is permitted to access is it’s own (the memory previously mentioned). A segmentation fault will result from any access outside of that region.

The segmentation fault in C++ may occur in the case where the program tries to:

1. Access the memory that it does not own.
2. Dereference nullptr or NULL pointer.
3. Modify Read-Only memory.

It is an error indicating memory corruption.

Common Segmentation Fault Scenarios

In a segmentation fault, a program tries to access memory that it is not authorized to access, or that does not exist. Some common scenarios that can cause segmentation faults are:

1. Modifying a String Literal
2. Accessing an Address that is Freed
3. Accessing Out of Array Index Bounds
4. Improper Use of scanf()
5. Stack Overflow
6. Dereferencing Uninitialized/NULL Pointer

1. Modifying a String Literal

The string literals are stored in the read-only section of the memory. That is why the below program may crash (gives segmentation fault error) because the line *(str+1) = ‘n’ tries to write a read-only memory.

Example:

// C++ program to demonstrate segmentation fault
// by modifying a string literal
#include <iostream>
using namespace std;

int main()
{
    char* str;

    // Stored in read only part of data segment //
    str = "GfG";

    // Problem:  trying to modify read only memory //
    *(str + 1) = 'n';
    return 0;
}

 Output

timeout: the monitored command dumped core

/bin/bash: line 1:    32 Segmentation fault      timeout 15s ./83b16132-8565-4cb1-aedb-4eb593442235 < 83b16132-8565-4cb1-aedb-4eb593442235.in

Refer, to Storage for Strings in C for more details.

2. Accessing an Address That is Freed

Here in the below code, the pointer p is dereferenced after freeing the memory block, which is not allowed by the compiler. Such pointers are called dangling pointers and they produce segment faults or abnormal program termination at runtime.

Example:

// C++ program to demonstrate segmentation fault
// by Accessing an address that is freed
#include <iostream>
using namespace std;

int main(void)
{
    // allocating memory to p
    int* p = (int*)malloc(sizeof(int));

    *p = 100;

    // deallocated the space allocated to p
    free(p);

    //  segmentation fault
    //  as now this statement is illegal
    *p = 110;

    return 0;
}

Output

Segmentation Fault

3. Accessing out-of-bounds Array Index

In C++, accessing an out-of-bounds array index may cause a segmentation fault or other undefined behavior. There is no boundary checking for arrays in C++. Although in C++, the use of containers such as with the std::vector::at() method or with an if() statement, can prevent out-of-bound errors.

Example:

// C++ program to demonstrate segmentation
// fault when array out of bound is accessed.
#include <iostream>
using namespace std;

int main()
{
    int arr[2];

    // Accessing out of bound
    arr[3] = 10;
    return 0;
}

Output

Segmentation Fault

4. Improper use of scanf()

The scanf() function expects the address of a variable as an input. Here in this program n takes a value of 2 and assumes its address as 1000. If we pass n to scanf(), input fetched from STDIN is placed in invalid memory 2 which should be 1000 instead. This causes memory corruption leading to a Segmentation fault.

Example:

// C++ program to demonstrate segmentation
// fault when value is passed to scanf
#include <iostream>
using namespace std;

int main()
{
    int n = 2;
    cin >> n;
    return 0;
}

Output

Segmentation Fault

5. Stack Overflow

It's not a pointer-related problem even code may not have a single pointer. It's because of running out of memory on the stack. It is also a type of memory corruption that may happen due to large array size, a large number of recursive calls, lots of local variables, etc.

Example:

// C++ program to illustrate 
// the segmentation fault 
// due to stack overflow
#include <iostream>
using namespace std;

int main()
{

    int array[2000000000];
    return 0;
}

Output

Segmentation Fault

6. Buffer Overflow

If the data being stored in the buffer is larger than the allocated size of the buffer, a buffer overflow occurs which leads to the segmentation fault. Most of the methods in the C++ do not perform bound checking, so buffer overflow happens frequently when we forget to allot the required size to the buffer.

Example:

// C++ program to illustrate the 
// segementation fault due to
// buffer overflow
#include <iostream>
using namespace std;

int main()
{

    char ref[20] = "This is a long string";
    char buf[10];
    sscanf(ref, "%s", buf);

    return 0;
}

Output

Segmentation Fault

7. Dereferencing an Uninitialized or NULL Pointer

It is a common programming error to dereference an uninitialized pointer (wild pointer), which can result in undefined behaviour. When a pointer is used in a context that treats it as a valid pointer and accesses its underlying value, even though it has not been initialized to point to a valid memory location, this error occurs. Data corruption, program errors, or segmentation faults can result from this. Depending on their environment and state when dereferencing, uninitialized pointers may yield different results.

As we know the NULL pointer does not points to any memory location, so dereferencing it will result in a segmentation fault.

Example:

// C++ program to demonstrate segmentation
// fault when uninitialized pointer 
// is accessed
#include <iostream>
using namespace std;

int main()
{
    int* ptr;
    int* nptr = NULL;
    cout << *ptr << " " << *nptr;
    return 0;
}

Output

(Segmentation Fault)

How to Identify the Cause of Segmentation Faults in C++?

To identify the cause of the segmentation faults, we can analyse the core dump created by the program with tools like gdb, etc. We can also directly run our program in GDB to check for segmentation faults. There are also many other tools like valgrind, Address Sanitizer, etc that can help you detect the segmentation faults and show why did it occurred.

Note: The core dump refers to the recording of the state of the program, i.e. its resources in memory and processor. Trying to access non-existent memory or memory which is being used by other processes also causes the Segmentation Fault which leads to a core dump.

How to Fix Segmentation Faults?

We can fix segmentation faults by being careful about the causes mentioned:

• Avoid modifying string literals or use the built in string container.
• Being careful when using pointers as they are one of the most common causes. You can also use the smart pointers instead of raw pointers.
• Considering the buffer and stack size before storing the data to avoid buffer or stack overflow.
• Checking for bounds before accessing array elements or use STL containers such as vectors, sets, maps, etc.
• Use scanf() and printf() carefully to avoid incorrect format specifiers or buffer overflow.

Conclusion

Overall, the cause of the segmentation fault is accessing the memory that does not belong to you in that space. As long as we avoid doing that, we can avoid the segmentation fault. If you cannot find the source of the error even after doing it, it is recommended to use a debugger as it directly leads to the point of error in the program.