Что такое segmentation fault (ошибка сегментации) в C++ и как её исправить?

Что такое segmentation fault?

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

Основные причины segmentation fault в C++

• Разыменование нулевого (nullptr) или неинициализированного указателя — самая частая причина.
• Выход за границы массива — доступ к arr[size] или arr[-1].
• Удаление памяти дважды (double delete) — повторный вызов delete для одного и того же указателя.
• Использование стека после возврата из функции — возврат указателя на локальную переменную.
• Переполнение стека (stack overflow) — бесконечная рекурсия или слишком большие локальные массивы.

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

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

int* ptr;   // Указатель не инициализирован, содержит "мусорный" адрес
*ptr = 10;  // Попытка записать 10 по случайному адресу — segmentation fault

Решение: всегда инициализируйте указатели перед использованием:

int value = 0;
int* ptr = &value;  // Теперь ptr указывает на существующую переменную
*ptr = 10;
cout << *ptr << endl;  // Выведет 10

Или используйте динамическую память:

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

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

int arr[5] = {1, 2, 3, 4, 5};
for (int i = 0; i <= 5; i++) {  // i = 5 — выход за границы!
    cout << arr[i] << " ";
}

В C++ компилятор не проверяет границы массивов — это сделано для производительности. Когда вы обращаетесь к arr[5], вы читаете память за пределами массива. Это может быть:

• Другая переменная программы
• Служебные данные (например, адрес возврата из функции)
• Память, принадлежащая другой программе — тогда ОС убьёт ваш процесс

Правильный цикл:

for (int i = 0; i < 5; i++) {  // i < 5, а не i <= 5
    cout << arr[i] << " ";
}

Другие типичные ситуации

Double delete:

int* p = new int(5);
delete p;
delete p;  // Ошибка! Память уже освобождена

Решение: после delete присвойте указателю nullptr:

delete p;
p = nullptr;
delete p;  // Безопасно: удаление nullptr — это no-op

Возврат указателя на локальную переменную:

int* getValue() {
    int x = 42;
    return &x;  // x уничтожится при выходе из функции
}

int main() {
    int* p = getValue();
    cout << *p;  // Segmentation fault или мусор
}

Решение: используйте динамическую память или передавайте переменную по ссылке.

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

1. Компилируйте с флагами отладки: g++ -g -Wall -Wextra program.cpp
2. Используйте valgrind (Linux/Mac): valgrind ./program — он покажет точную строку ошибки и состояние памяти.
3. Запускайте в GDB: gdb ./program, затем run, при падении bt (backtrace) покажет стек вызовов.
4. Вставляйте отладочный вывод: cout << "Step 1" << endl; — чтобы понять, где именно происходит падение.

Главное правило: всегда инициализируйте переменные, проверяйте границы массивов и не забывайте освобождать память. С опытом вы научитесь предвидеть эти ошибки.

#include <memory>
std::unique_ptr<int> ptr = std::make_unique<int>(10);
// delete не нужен — память освободится автоматически

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

try {
    vec.at(10) = 42;  // Выбросит std::out_of_range, а не segmentation fault
} catch (const std::out_of_range& e) {
    cerr << "Ошибка: " << e.what() << endl;
}