Что такое segmentation fault (ошибка сегментации) в C++ и почему она возникает?

Что такое segmentation fault?

Segmentation fault (ошибка сегментации) — это ошибка, возникающая, когда программа пытается обратиться к области памяти, доступ к которой ей запрещён операционной системой. В современных ОС каждому процессу выделяется своё виртуальное адресное пространство, разделённое на сегменты (код, данные, стек, куча). Если программа пытается читать или писать за пределами разрешённых сегментов, процессор генерирует исключение, и ОС завершает процесс с сигналом SIGSEGV.

Почему возникает segmentation fault?

Основные причины:

• Разыменование нулевого или неинициализированного указателя — самая частая причина. Указатель должен указывать на валидную память.
• Выход за границы массива — доступ к элементу за пределами выделенной памяти.
• Использование после освобождения (use-after-free) — обращение к памяти, которая уже была возвращена системе через delete или free.
• Переполнение стека — например, бесконечная рекурсия или слишком большой локальный массив.
• Повреждение кучи — запись за пределы выделенного блока new/malloc.

Разбор ваших примеров

Пример 1: неинициализированный указатель

int* ptr;       // Указатель не инициализирован! Он содержит мусорный адрес
*ptr = 42;      // Попытка записать по мусорному адресу — почти гарантированный SIGSEGV

Указатель ptr не указывает ни на какую выделенную память. При разыменовании вы пытаетесь записать 42 по случайному адресу, который может принадлежать другому процессу или защищённой области. Решение: всегда инициализируйте указатели.

int* ptr = new int;  // Выделяем память в куче
*ptr = 42;
cout << *ptr;
delete ptr;          // Не забываем освободить!

Или используйте стек:

int var = 0;
int* ptr = &var;     // Указываем на существующую переменную
*ptr = 42;

Пример 2: выход за границы массива

int arr[5] = {1,2,3,4,5};
for (int i = 0; i <= 5; i++) {  // Ошибка: i <= 5, а должно быть i < 5
    cout << arr[i];             // arr[5] — выход за границу!
}

Массив arr имеет индексы от 0 до 4. Обращение к arr[5] — это чтение из памяти, которая не принадлежит массиву. Иногда это может пройти незамеченным (если там "мусор"), но часто вызывает segmentation fault, особенно если память защищена. Решение: всегда проверяйте границы.

for (int i = 0; i < 5; i++) {  // Правильно: строго меньше размера
    cout << arr[i];
}

Как отлаживать segmentation fault?

• Компилируйте с флагами отладки: g++ -g -Wall -Wextra program.cpp
• Используйте GDB: запустите gdb ./program, затем run. После падения введите bt (backtrace), чтобы увидеть стек вызовов.
• Valgrind: valgrind ./program — покажет точное место утечки или некорректного доступа.
• Проверяйте все указатели на nullptr перед разыменованием.
• Используйте std::vector вместо сырых массивов — у него есть метод .at(), который бросает исключение при выходе за границы.

Помните: segmentation fault — это не "ошибка компиляции", а ошибка времени выполнения. Она защищает вашу систему от повреждения, но требует от вас аккуратной работы с памятью.

#include <memory>
std::unique_ptr<int> ptr = std::make_unique<int>(42);
// delete не нужен — память освободится при выходе из области видимости

#include <vector>
std::vector<int> vec = {1,2,3,4,5};
for (size_t i = 0; i < vec.size(); ++i) {  // Гарантированно безопасно
    std::cout << vec[i];
}
// Или ещё лучше — range-based for:
for (int x : vec) {
    std::cout << x;
}