Память в C++ простыми словами: стек, куча, указатели и утечки памяти без боли

Есть два типа разработчиков.

Первый пишет код, нажимает Run - и всё работает.

Второй пишет код, нажимает Run - и получает:

Segmentation fault (core dumped)

После этого начинается расследование уровня криминального сериала: кто обращался к памяти, куда исчез указатель и почему программа умерла именно сейчас, хотя пять минут назад всё было нормально. 😅

Добро пожаловать в мир памяти C++.

Если Python, JavaScript или Java стараются спрятать большую часть работы с памятью, то C++ вручает тебе ключи от всего здания и говорит:

Вот память. Управляй. Только потом не говори, что тебя не предупреждали.

Именно управление памятью делает C++ одновременно мощным, быстрым и немного пугающим. Но когда понимаешь основные принципы, большая часть «магии» исчезает.

🧠 Что вообще такое память программы?

Когда программа запускается, операционная система выделяет ей пространство в оперативной памяти. Там хранятся переменные, объекты, массивы, аргументы функций и другие данные, необходимые для работы.

Условно память программы можно представить как большое здание с разными помещениями. Для новичка особенно важны две зоны:

• стек - Stack;

• куча - Heap.

Названия звучат так, будто речь идёт либо о книгах, либо о мусорной свалке. И, что забавно, это довольно точное описание.

📚 Стек: быстро, аккуратно и автоматически

Стек используется для хранения локальных переменных, аргументов функций и служебной информации о вызовах функций.

void printAge(){
int age=25;
std::cout<<age;
}

Переменная age создаётся, когда начинается выполнение функции, и автоматически удаляется, когда функция заканчивается.

Тебе не нужно вручную освобождать память. Компилятор и сама структура стека делают это за тебя.

Стек работает по принципу LIFO - Last In, First Out: последним пришёл, первым ушёл.

Представь стопку тарелок. Чтобы достать нижнюю тарелку, сначала придётся убрать все верхние. С вызовами функций происходит примерно то же самое.

Почему стек быстрый?

Для выделения памяти в стеке системе обычно достаточно сдвинуть специальный указатель. Не нужно искать свободное место среди множества блоков памяти.

Поэтому стек:

• работает очень быстро;

• автоматически очищается;

• предсказуемо управляет временем жизни объектов;

• обычно безопаснее ручного выделения памяти.

Но стек не бесконечный. Если положить туда слишком много данных, можно получить переполнение.

int main(){
int hugeArray[100000000];
}

Такой массив может привести к ошибке Stack Overflow.

И нет, это не тот сайт, на котором ты копируешь решение ошибки. Это сама ошибка. 😄

📦 Куча: много места, но порядок наводишь сам

Куча - это область динамической памяти. Она нужна, когда размер данных становится известен только во время выполнения программы или объект должен жить дольше текущей функции.

int* number=new int(42);

Оператор new выделяет память в куче и возвращает её адрес. Этот адрес сохраняется в указателе number.

Но здесь начинается самое интересное: выделенная память не освобождается автоматически после выхода из функции.

Её нужно освободить вручную:

delete number;

Забыл написать delete? Поздравляем, ты создал утечку памяти.

💧 Что такое утечка памяти?

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

void createNumber(){
int* value=new int(100);
}

Функция завершилась, локальный указатель value исчез, а выделенная память осталась занятой.

Программа уже не знает адрес этого участка и не может вызвать для него delete.

Представь гостиницу, в которой приложение постоянно бронирует новые номера, но никогда не оформляет выезд. Сначала всё работает нормально. Потом свободных номеров становится всё меньше. Затем гостиница превращается в сервер, который нужно срочно перезапустить.

В маленькой программе одна утечка может быть незаметна. В игре, браузере, сервере или приложении, которое работает сутками, постоянные утечки приводят к росту потребления памяти, тормозам и падениям.

👻 Висячий указатель

После вызова delete память освобождается, но сам указатель автоматически не исчезает.

int* number=new int(10);
delete number;

Переменная number всё ещё содержит старый адрес. Но объект по этому адресу уже уничтожен.

Если попробовать обратиться к нему:

std::cout<<*number;

программа попадает в область неопределённого поведения.

Она может:

• вывести старое значение;

• вывести случайное число;

• упасть;

• сломать другие данные;

• продолжить работу, чтобы упасть позже в совершенно другом месте.

Такой указатель называется висячим указателем, или dangling pointer.

После ручного освобождения памяти указатель часто обнуляют:

delete number;
number=nullptr;

Это не исправляет все возможные проблемы, но снижает риск случайного повторного обращения к освобождённому объекту.

💥 Двойное освобождение памяти

Иногда разработчик настолько старается не допустить утечку, что освобождает память дважды.

int* number=new int(42);
delete number;
delete number;

Первый delete корректно освобождает память. Второй пытается освободить участок, который уже возвращён системе.

Это снова неопределённое поведение.

Компьютер в такой момент примерно:

Ты уже удалил это. Что именно я должен удалить сейчас?

Поэтому ручное управление памятью требует строгой дисциплины. Один забытый или лишний delete способен создать ошибку, которую придётся искать несколько часов.

🔗 Указатели: не данные, а адреса

Указатель - это переменная, которая хранит адрес другой переменной или объекта.

int value=50;
int* pointer=&value;

Здесь:

• value хранит число 50;

• &value получает адрес переменной;

• pointer хранит этот адрес;

• *pointer получает значение по адресу.

std::cout<<*pointer;

Программа выведет 50.

Указатели нужны для динамической памяти, эффективной передачи объектов, создания структур данных и взаимодействия с низкоуровневыми API.

Но указатель сам по себе не знает:

• существует ли объект по адресу;

• сколько памяти там выделено;

• можно ли её освобождать;

• кто отвечает за время жизни объекта.

Указатель просто хранит адрес. Вся ответственность остаётся у разработчика.

🏗️ Когда нужна динамическая память?

Куча используется не потому, что разработчикам нравится писать delete. Она решает реальные задачи.

Динамическая память нужна, когда:

• размер массива неизвестен заранее;

• объект должен существовать после завершения функции;

• создаются деревья, графы и связанные списки;

• объекты создаются в зависимости от действий пользователя;

• данные слишком большие для стека;

• нужно управлять временем жизни объекта независимо от области видимости.

Например, количество игровых противников определяется уже во время игры. Создать заранее переменную под каждого возможного врага невозможно. Поэтому объекты создаются динамически.

🚀 Почему современный C++ не любит ручные new и delete?

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

Поэтому современный C++ использует принцип RAII - Resource Acquisition Is Initialization.

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

Вместо обычного указателя:

User* user=new User();
delete user;

можно использовать умный указатель:

auto user=std::make_unique<User>();

Когда user выйдет из области видимости, память освободится автоматически.

Не нужно вручную писать delete. Меньше кода, меньше ошибок, меньше ночных сообщений в рабочем чате с текстом «прод снова упал».

🧠 std::unique_ptr

std::unique_ptr означает, что объектом владеет только один указатель.

#include <memory>
auto player=std::make_unique<Player>();

Такой указатель нельзя просто скопировать:

auto secondPlayer=player;

Этот код не скомпилируется, потому что у объекта должен быть только один владелец.

Но владение можно передать:

auto secondPlayer=std::move(player);

После этого объектом владеет secondPlayer, а исходный указатель становится пустым.

std::unique_ptr - хороший выбор по умолчанию, когда объекту нужен один понятный владелец.

🤝 std::shared_ptr

std::shared_ptr используется, когда одним объектом должны совместно владеть несколько частей программы.

auto user=std::make_shared<User>();
auto anotherReference=user;

Умный указатель считает количество владельцев. Пока существует хотя бы один shared_ptr, объект остаётся в памяти.

Когда последний владелец исчезает, память освобождается автоматически.

Звучит идеально, но у shared_ptr есть цена: дополнительный счётчик ссылок и риск циклических зависимостей.

Например, объект A хранит shared_ptr на B, а B - shared_ptr на A. Оба объекта считают, что другой всё ещё ими владеет, поэтому никогда не уничтожаются.

Для решения этой проблемы существует std::weak_ptr.

🧹 Контейнеры тоже управляют памятью

Во многих случаях тебе вообще не нужно напрямую работать с динамической памятью.

Вместо динамического массива:

int* numbers=new int[size];
delete[] numbers;

лучше использовать:

std::vector<int> numbers(size);

std::vector сам выделяет память, расширяется и освобождает ресурсы.

Современный C++ предлагает готовые инструменты:

• std::vector - динамический массив;

• std::string - строка;

• std::array - массив фиксированного размера;

• std::unique_ptr - уникальное владение;

• std::shared_ptr - совместное владение;

• std::optional - значение, которое может отсутствовать.

Чем чаще используешь стандартные контейнеры и RAII, тем реже приходится вручную вспоминать, где поставить delete.

🔍 Почему ошибки памяти так сложно искать?

Главная проблема ошибок памяти - они не всегда проявляются в момент появления.

Ты можешь случайно записать данные за пределами массива:

int numbers[3]={1,2,3};
numbers[10]=42;

Программа может не упасть сразу. Она просто перезапишет чужой участок памяти.

Падение произойдёт позже - например, при выводе текста, создании объекта или закрытии программы.

Разработчик смотрит на строку, где произошёл сбой, и думает:

Почему программа падает на обычном std::cout?

А настоящая ошибка находится на 300 строк выше.

Для поиска таких проблем используют:

• AddressSanitizer;

• Valgrind;

• отладчик;

• статические анализаторы;

• предупреждения компилятора.

Например, AddressSanitizer помогает обнаруживать выход за границы массива, обращение к освобождённой памяти и двойное освобождение.

⚙️ Базовые правила работы с памятью в C++

1. Старайся хранить объекты на стеке. Если динамическая память не нужна, не создавай её.

2. Используй стандартные контейнеры. std::vector почти всегда лучше ручного динамического массива.

3. Предпочитай std::unique_ptr. Он явно показывает владельца объекта.

4. Не используй new и delete без необходимости. Современный C++ позволяет обходиться без них в большинстве обычных задач.

5. Не обращайся к объекту после его уничтожения.

6. Не освобождай один и тот же участок памяти дважды.

7. Включай предупреждения компилятора. Иногда компилятор замечает проблему раньше тебя.

8. Проверяй код санитайзерами. Особенно если программа ведёт себя случайным образом.

💙 Как изучать C++ без бесконечной теории?

Память невозможно нормально понять, просто прочитав определения стека, кучи и указателей.

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

В приложении Кодик обучение программированию построено вокруг практики. Ты изучаешь C++, пишешь код прямо во время уроков, решаешь упражнения и постепенно закрепляешь сложные темы: переменные, функции, массивы, указатели, классы и управление памятью.

Не просто читаешь, как работает std::vector, а используешь его. Не просто запоминаешь определение указателя, а работаешь с адресами и видишь результат выполнения программы.

А в Telegram-сообществе Кодика регулярно выходят полезные посты, небольшие разборы, шпаргалки, мемы и практические материалы для разработчиков. Это удобный способ повторять программирование, даже когда нет времени проходить полноценный урок.