Глубокое погружение в указатели C++

Управление динамической памятью: куча, операторы new и delete, утечки памяти

Добро пожаловать обратно на курс «Глубокое погружение в указатели C++». В предыдущих статьях мы научились работать с адресами, арифметикой указателей и массивами. Однако до сих пор мы были ограничены жесткими рамками: размер наших массивов должен был быть известен еще до запуска программы (на этапе компиляции), а переменные жили ровно столько, сколько выполнялась функция, в которой они были созданы.

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

Стек и Куча: два мира памяти

Чтобы понять суть динамической памяти, нужно разобраться, как программа использует оперативную память (RAM). Память делится на два основных сегмента:

Стек (Stack)

Куча (Heap)

Стек (Stack)

Это область памяти для локальных переменных и вызовов функций. Стек работает очень быстро и управляется автоматически. Когда вы пишете int x = 10; внутри функции, переменная создается на стеке. Когда функция завершается, переменная автоматически уничтожается («выталкивается» со стека).

Ограничения стека: * Размер: Стек обычно невелик (несколько мегабайт). Попытка создать здесь огромный массив приведет к переполнению стека (Stack Overflow). * Жизненный цикл: Переменные живут только внутри своей области видимости { ... }.

Куча (Heap)

Это огромное пространство памяти, доступное программисту для ручного управления. Здесь переменные могут жить столько, сколько мы захотим, и занимать столько места, сколько позволяет физическая память компьютера.

!Стек — это упорядоченная структура с автоматическим управлением, а Куча — свободное пространство для ручного размещения данных.

Оператор new: запрос памяти

В C++ для выделения памяти в куче используется оператор new. Он выполняет три действия:

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

Вызывает конструктор объекта (если это класс или структура).

Возвращает адрес начала этого блока.

Именно поэтому new всегда работает в связке с указателями.

Выделение памяти под одну переменную

Мы также можем сразу инициализировать значение:

Выделение памяти под массив

Самое мощное применение new — создание динамических массивов, размер которых определяется во время выполнения программы.

Если мы представим это математически, то объем выделяемой памяти можно рассчитать по формуле:

где: * — общий объем выделенной памяти в байтах; * — количество элементов (в нашем случае size); * — размер одного элемента в байтах (например, sizeof(int)).

Оператор delete: освобождение памяти

В языках вроде Java или Python есть «сборщик мусора» (Garbage Collector), который ходит за вами и убирает неиспользуемые объекты. В C++ сборщика мусора нет.

Это означает: всё, что вы выделили с помощью new, вы обязаны удалить с помощью delete. Если вы этого не сделаете, память останется занятой до самого завершения программы.

Удаление одиночного объекта

Удаление массива

Для массивов используется специальная форма оператора с квадратными скобками []. Это критически важно!

> Золотое правило: Если использовали new, используйте delete. Если использовали new[], используйте delete[].

Утечки памяти (Memory Leaks)

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

Пример утечки

Если вызывать эту функцию в цикле миллион раз, программа «съест» всю доступную оперативную память и операционная система принудительно её закроет (или компьютер зависнет).

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

Висячие указатели (Dangling Pointers)

После вызова delete ptr; память освобождается, но переменная ptr всё еще хранит старый адрес. Этот адрес теперь указывает на «мусор» или на данные, уже занятые другой программой.

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

Как избежать: Сразу после удаления присваивайте указателю значение nullptr.

Это безопасно, так как удаление nullptr (delete nullptr) — это легальная операция, которая просто ничего не делает.

Динамическая память и функции

Динамическая память позволяет создавать объекты в одной функции и передавать их в другую, не заботясь о том, что они исчезнут при выходе из функции-создателя.

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

Заключение

Сегодня мы вышли за пределы стека и научились управлять «большой» памятью.

Ключевые выводы:

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

new выделяет память, delete освобождает её.

Для массивов используйте пару new[] и delete[].

Забытый delete приводит к утечкам памяти.

Использование указателя после удаления приводит к ошибкам. Зануляйте указатели после delete.

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

Сложные концепции: указатели на функции, указатели на указатели и const-корректность

Приветствую вас на очередной лекции курса «Глубокое погружение в указатели C++». Мы уже прошли долгий путь: от понимания того, что такое адрес памяти, до управления динамическими массивами в куче. Казалось бы, что может быть сложнее?

Однако C++ не был бы собой, если бы не позволял строить абстракции любой глубины. Сегодня мы переходим к темам, которые отделяют новичка от профессионала. Мы узнаем, как создавать указатели на другие указатели, как защищать данные с помощью const на молекулярном уровне и, наконец, как хранить адреса не данных, а самого кода — функций.

Указатели на указатели (Double Pointers)

До сих пор мы рассматривали указатель как переменную, которая хранит адрес значения (например, int или char). Но ведь сам указатель — это тоже переменная, которая занимает место в памяти. А раз у него есть место в памяти, значит, у него есть адрес. А раз есть адрес, мы можем создать указатель, который будет хранить этот адрес.

Это называется многоуровневой косвенной адресацией (multiple indirection).

Синтаксис и логика

Чтобы объявить указатель на указатель, мы используем две звездочки **:

Давайте разберем, что здесь происходит, используя математическую нотацию. Пусть — это адрес переменной . Тогда:

где — значение переменной ptr, а — адрес переменной value.

Для двойного указателя формула выглядит так:

где — значение переменной ptrPtr, которое является адресом переменной ptr.

!Визуализация цепочки указателей: указатель на указатель ссылается на обычный указатель, который ссылается на значение.

Разыменование двойного указателя

Чтобы добраться до исходного значения 42, нам нужно применить оператор разыменования дважды:

*ptrPtr дает нам значение ptr (то есть адрес value).

**ptrPtr дает нам значение value (число 42).

Зачем это нужно?

Существует две основные причины использования двойных указателей:

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

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

Пример создания динамической матрицы :

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

Const-корректность и указатели

Ключевое слово const в C++ — это инструмент защиты и самодокументирования кода. Когда дело доходит до указателей, новички часто путаются, где именно ставить const и на что он влияет.

Существует простое правило: читайте объявление справа налево.

Рассмотрим три основных случая:

1. Указатель на константу (Pointer to Constant)

Читаем справа налево: ptr — это указатель (*) на int, который является константой (const).

* Можно: изменить сам указатель (ptr = &y). Нельзя: изменить значение по адресу (ptr = 10 — ошибка).

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

2. Константный указатель (Constant Pointer)

Читаем справа налево: ptr — это константный (const) указатель (*) на int.

Можно: изменить значение по адресу (ptr = 10). * Нельзя: изменить сам указатель (ptr = &y — ошибка).

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

3. Константный указатель на константу

Здесь запрещено всё. Мы не можем ни изменить адрес, ни изменить данные по этому адресу. Это максимальный уровень защиты.

Таблица истинности const

| Объявление | Можно менять ptr? | Можно менять *ptr? | | :--- | :---: | :---: | | int* ptr | Да | Да | | const int* ptr | Да | Нет | | int* const ptr | Нет | Да | | const int* const ptr | Нет | Нет |

Указатели на функции

Это, пожалуй, самая захватывающая часть сегодняшней лекции. Мы привыкли, что указатели хранят адреса данных. Но код вашей программы — инструкции процессора — тоже загружается в оперативную память. У каждой функции есть свой адрес начала выполнения.

Если у функции есть адрес, мы можем сохранить его в указатель. Это позволяет передавать функции как аргументы в другие функции, создавая гибкие механизмы обратного вызова (callbacks).

Синтаксис

Синтаксис объявления указателя на функцию может показаться пугающим. Рассмотрим пример:

Разберем структуру int (*funcPtr)(int, int):

int (первый) — тип возвращаемого значения функции.

(*funcPtr) — имя указателя в скобках. Скобки обязательны! Без них компилятор подумает, что вы объявляете функцию, которая возвращает указатель на int.

(int, int) — типы аргументов, которые принимает функция.

Использование

Присвоить адрес функции указателю очень просто — достаточно использовать имя функции:

Практическое применение: Callback-функции

Представьте, что вы пишете функцию сортировки массива. Вы знаете, как переставлять элементы, но вы не знаете, как именно пользователь хочет их сравнивать (по возрастанию, по убыванию, по модулю).

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

Теперь мы можем сортировать массив как угодно, просто меняя передаваемую функцию:

Упрощение синтаксиса с помощью typedef и using

Чтобы не писать громоздкие конструкции вроде void (*p)(int, double), в современном C++ используют псевдонимы типов.

Старый стиль (typedef):

Современный стиль (using):

Это делает код намного более читаемым, особенно когда указатели на функции передаются как аргументы.

Массив указателей на функции

Мы можем пойти еще дальше и создать массив указателей на функции. Это часто используется для создания простых меню или конечных автоматов (state machines).

Это позволяет избежать длинных цепочек if-else или switch-case.

Заключение

Сегодня мы значительно расширили наш инструментарий. Мы узнали:

Указатели на указатели ()** позволяют создавать многомерные структуры и менять указатели внутри функций.

Const-корректность — это способ защитить данные от случайного изменения, и важно различать const type и type const.

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

Эти концепции могут показаться абстрактными, но они лежат в основе архитектуры большинства сложных систем на C++. В следующей части курса мы отойдем от «сырых» указателей и познакомимся с современными инструментами управления памятью — умными указателями (Smart Pointers), которые делают работу с памятью безопасной и автоматической.

Готовы проверить, насколько глубоко вы усвоили материал? Переходите к заданиям!

Умные указатели в современном C++: unique_ptr, shared_ptr и weak_ptr

В предыдущей статье мы научились управлять динамической памятью вручную, используя операторы new и delete. Мы увидели мощь этого подхода, но также столкнулись с его главной опасностью: человеческим фактором. Забыли вызвать delete? Утечка памяти. Вызвали delete дважды? Крах программы. Обратились к памяти после удаления? Неопределенное поведение.

В современном C++ (начиная со стандарта C++11) ручное управление памятью считается «плохим тоном» в большинстве ситуаций. На смену «сырым» указателям (raw pointers) пришли умные указатели (smart pointers). Они берут на себя всю грязную работу по очистке памяти, делая код безопасным и выразительным.

Философия RAII

Прежде чем разбирать конкретные типы умных указателей, нужно понять концепцию, на которой они строятся. Это RAII (Resource Acquisition Is Initialization — Получение ресурса есть инициализация).

Суть идиомы проста:

Захват ресурса (выделение памяти) происходит в конструкторе объекта.

Освобождение ресурса (очистка памяти) происходит автоматически в деструкторе объекта.

Поскольку локальные объекты на стеке уничтожаются автоматически при выходе из области видимости (функции или блока {}), деструктор умного указателя гарантированно вызовется и освободит динамическую память, на которую он указывает. Даже если в функции произойдет ошибка или будет выброшено исключение.

std::unique_ptr: Единоличный владелец

Самый простой, быстрый и часто используемый умный указатель — это std::unique_ptr. Его название говорит само за себя: он гарантирует, что у объекта в памяти есть только один владелец.

Как это работает?

Когда std::unique_ptr уничтожается (выходит из области видимости), он автоматически вызывает delete для объекта, которым владеет.

Запрет копирования

Поскольку владелец может быть только один, std::unique_ptr нельзя скопировать. Если бы мы скопировали указатель, у нас было бы два объекта, считающих себя единственными владельцами. При уничтожении оба попытались бы удалить одну и ту же память (double free error).

Передача владения (Move semantics)

Хотя копировать нельзя, владение можно передать. Для этого используется функция std::move. Это похоже на передачу эстафетной палочки: старый указатель становится пустым (nullptr), а новый получает полный контроль над ресурсом.

!Визуализация перемещения ресурса: p1 теряет связь с объектом, а p2 получает её.

std::make_unique

Начиная с C++14, рекомендуется не использовать new напрямую, а использовать фабричную функцию std::make_unique. Это безопаснее и короче.

std::shared_ptr: Совместное владение

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

Для этого существует std::shared_ptr.

Подсчет ссылок

std::shared_ptr использует механизм подсчета ссылок (reference counting). Рядом с самим объектом в куче создается специальный «контрольный блок» (control block), в котором хранится счетчик.

Математически логику жизни объекта можно описать так. Пусть — количество активных ссылок.

где: * — текущее значение счетчика ссылок в момент времени . * — начальное создание (обычно 1). * — количество операций копирования указателя. * — количество уничтоженных указателей (вызовов деструктора).

Память освобождается тогда и только тогда, когда выполняется условие:

где: * — счетчик ссылок. * — отсутствие владельцев.

!Три указателя shared_ptr ссылаются на один и тот же управляющий блок, который хранит счетчик ссылок.

Пример использования

В отличие от unique_ptr, shared_ptr можно свободно копировать.

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

std::weak_ptr: Слабая ссылка

У shared_ptr есть ахиллесова пята: циклические ссылки. Представьте ситуацию: * Объект А хранит shared_ptr на объект Б. * Объект Б хранит shared_ptr на объект А.

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

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

Наблюдатель без владения

std::weak_ptr — это «слабый» указатель. Он ссылается на объект, управляемый shared_ptr, но не увеличивает счетчик ссылок. Он выступает в роли наблюдателя.

Если основной shared_ptr удалит объект, weak_ptr просто «протухнет» (станет указывать в никуда), но не помешает удалению.

!Слева показана проблема циклической зависимости, приводящая к утечке. Справа — решение с использованием weak_ptr.

Как использовать weak_ptr

Напрямую разыменовать weak_ptr нельзя (ведь объект мог быть уже удален). Сначала нужно превратить его в shared_ptr с помощью метода lock().

Какой указатель выбрать?

Выбор правильного инструмента — залог качественной архитектуры. Следуйте этому простому алгоритму:

По умолчанию используйте std::unique_ptr. Это самый быстрый и безопасный вариант для 90% случаев. Если объект принадлежит только одной сущности — это ваш выбор.

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

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

Не используйте сырые указатели (*) для владения ресурсами. Используйте их только как «не владеющие» ссылки для передачи в функции (аналог weak_ptr, но без проверки на существование).

Заключение

Умные указатели — это фундамент безопасности в современном C++. Они позволяют писать код, который не течет и не падает, сохраняя при этом высокую производительность.

Мы разобрали: * unique_ptr для эксклюзивного владения. * shared_ptr для совместного владения через подсчет ссылок. * weak_ptr для предотвращения циклов.

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