Что такое утечка памяти в C++?

Question

Что такое утечка памяти в C++?

Тип вопроса: Управление памятью Вероятность: 25% Категория: C/C++ Разработчик

Ответ

Утечка памяти — это ситуация, когда программа выделяет память (например, оператором new или функцией malloc), но не освобождает её (оператором delete или функцией free), и при этом теряются все указатели на эту область памяти. В результате эта память остается занятой до завершения работы программы.

Классический пример утечки:

void createLeak() {
    int* dynamicArray = new int[1000]; // Выделение памяти
    // ... использование массива ...
    // Забыли выполнить delete[] dynamicArray;
    // После выхода из функции указатель dynamicArray уничтожается,
    // а память на 1000 int остаётся занятой и недоступной.
}

Более коварный пример через исключение:

void riskyFunction() {
    int* ptr = new int(42);
    someFunctionThatMightThrow(); // Если исключение выброшено здесь,
    delete ptr;                   // эта строка не выполнится.
}

Как предотвращать утечки в современном C++:

Использовать умные указатели (RAII):

#include <memory>
void safeFunction() {
    auto ptr = std::make_unique<int>(42); // std::unique_ptr
    // Память будет автоматически освобождена при выходе из области видимости,
    // даже если будет выброшено исключение.
}

Использовать контейнеры STL: Вместо ручного управления массивами используйте std::vector, std::string и т.д.
Следовать правилу "пяти/нуля" (Rule of Five/Zero): Корректно определять или запрещать специальные функции-члены для классов, управляющих ресурсами.
Использовать инструменты для обнаружения:
- Санитайзеры (GCC/Clang): -fsanitize=address
- Valgrind (Memcheck)
- Встроенные средства IDE (Visual Studio Debugger, Qt Creator)

Циклические ссылки с std::shared_ptr — особая форма утечки, решаемая с помощью std::weak_ptr.

Ответ 18+ 🔞

А, слушай, вот тебе история про одну из самых классических и тупых проблем в C++. Утечка памяти. Это когда твоя программа, как не в себя, начинает хавать оперативку, пока система не накроется медным тазом. Суть проста, как три копейки: ты выделил память через new или malloc, а потом проебал её освободить. И хуже того — потерял все указатели на этот кусок. Получается, память висит мёртвым грузом до конца работы программы, как пидарас шерстяной на заборе.

Вот тебе классика жанра, прям учебный пример:

void createLeak() {
    int* dynamicArray = new int[1000]; // Выделили память
    // ... что-то делаем с массивом ...
    // А вот delete[] dynamicArray; — забыли написать, ёпта!
    // Функция закончилась, указатель dynamicArray сдох,
    // а память на 1000 int так и осталась занятой. Овердохуища мусора.
}

А вот пример похитрее, через исключения — тут уже хитрая жопа:

void riskyFunction() {
    int* ptr = new int(42);
    someFunctionThatMightThrow(); // Если здесь вылетит исключение,
    delete ptr;                   // до этой строчки дело не дойдёт. Всё, пиши пропало.
}

Как с этим бороться, чтобы не было мучительно больно:

Юзай умные указатели, блядь! (RAII): Это святое.

#include <memory>
void safeFunction() {
    auto ptr = std::make_unique<int>(42); // std::unique_ptr
    // Память сама освободится при выходе из функции,
    // даже если весь мир рухнет и полетят исключения. Красота.
}

Используй контейнеры STL: Забудь про ручное управление массивами. Бери std::vector, std::string — они сами всё порешают.
Следуй правилу "пяти/нуля" (Rule of Five/Zero): Если пишешь класс, который управляет ресурсами, либо правильно определяй все специальные функции (конструктор копирования, перемещения и т.д.), либо вообще их запрещай. Или лучше — не пиши такие классы, доверься стандартной библиотеке.
Лови утечки инструментами:
- Санитайзеры (GCC/Clang): Просто добавляешь флаг -fsanitize=address и спишь спокойно.
- Valgrind (Memcheck): Старый добрый монстр, который всё найдёт.
- Отладчики в IDE: В том же Visual Studio или Qt Creator есть встроенные средства, которые могут показывать утечки.

Отдельная песня — циклические ссылки с std::shared_ptr. Это когда два умных указателя друг на друга ссылаются, и счётчики ссылок никогда не обнуляются. Получается утечка, хоть и умная. Лечится это std::weak_ptr — он не увеличивает счётчик ссылок, поэтому цикл не образуется. Запомни это, а то будет тебе хиросима и нигерсраки в коде.