Память

delete освобождает один объект, вызывая его деструктор один раз; delete[] освобождает массив new[], вызывая деструктор для каждого элемента. Несоответствие — UB и может испортить метаданные кучи, пропустить деструкторы или привести к падению.

Утечка памяти — это динамически выделенная память, которая никогда не освобождается; если delete пропущен, деструктор не вызывается, блок кучи остаётся занятым и со временем приводит к OOM в долгоживущих процессах.

new выделяет память и конструирует объект; delete вызывает деструктор и освобождает память. malloc/free работают только с сырыми байтами и ничего не знают о конструкторах, деструкторах и типах C++.

Указатель хранит адрес объекта; его размер зависит от платформы (8 байт на 64-битной) независимо от типа. Операции: *p, &x, p->m. Арифметика определена только внутри массивов: p + n сдвигает на n * sizeof(*p) байт.

Resource Acquisition Is Initialization: ресурс захватывается в конструкторе и освобождается в деструкторе. C++ гарантирует вызов деструктора даже при раскрутке стека, поэтому RAII делает очистку автоматической и exception-safe.

Стек — автоматический, LIFO, ограничен (обычно 1–8 МБ); освобождение при выходе из области видимости. Куча — ручное или через умные указатели, практически без ограничений, но с накладными расходами аллокатора и фрагментацией.

unique_ptr владеет объектом единолично и только перемещается. shared_ptr разделяет владение через control block со счётчиками ссылок. weak_ptr наблюдает за тем же control block, но не продлевает жизнь объекта; он нужен для разрыва циклов и проверки, жив ли объект.

malloc(size) выделяет неинициализированные байты; calloc(count, size) выделяет count * size байт, обнуляет их и проверяет умножение на переполнение. Оба освобождаются free, никогда delete.

RAII-обёртка с нулевыми накладными расходами, эксклюзивно владеющая heap-объектом — некопируемая, но перемещаемая. При уничтожении или reset вызывает delete (или custom deleter). Владение передаётся явно через std::move(up).

Выравнивание требует, чтобы адрес типа был кратен его alignof (например, int на 4-байтовой границе). Компилятор вставляет padding, поэтому размер структуры ≠ сумме полей. Невыровненный доступ вызывает аппаратные сбои на строгих CPU и лишние шинные транзакции на остальных.

Запись за пределы выделенного региона портит соседнюю память: на стеке перезаписывается адрес возврата (stack smashing); на куче — метаданные аллокатора. Обнаруживается через AddressSanitizer, Valgrind или стековые канарейки.

Двойное освобождение — неопределённое поведение: портит метаданные кучи, хранящиеся рядом с выделениями, и может вызвать падение, молча испортить данные или создать уязвимость. AddressSanitizer (-fsanitize=address) обнаруживает это мгновенно во время выполнения.

Если doWork бросает исключение, delete[] buf пропускается при раскрутке стека, и буфер утекает — ручные new/delete не безопасны при исключениях. Решение через RAII: std::vector<int> buf(1000); или auto buf = std::make_unique<int[]>(1000);, освобождаемые автоматически при раскрутке.

make_shared<T>(args) делает одно выделение для объекта и control block, тогда как shared_ptr<T>(new T) — два. Он быстрее, имеет лучшую cache locality и устраняет утечку при броске исключения между new и конструктором shared_ptr.

Неопределённое поведение: память из new[] нужно освобождать через delete[], а не delete. Их несоответствие — UB, обычно утечка или повреждение кучи. Решение: написать delete[] arr или отказаться от сырых массивов в пользу std::vector<int> или std::make_unique<int[]>(100).

Heap-аллоцированная структура с strong refcount, weak refcount, deleter и аллокатором; и shared_ptr, и weak_ptr ссылаются на неё. Объект удаляется при обнулении strong count; control block живёт, пока weak count тоже не обнулится.

Доступ после delete — неопределённое поведение. Программа может упасть, выглядеть рабочей, прочитать старые данные, испортить другой объект или сломаться позже. Аллокатор может сразу переиспользовать этот блок, а стандарт C++ не даёт гарантий.

Циклы, где A и B держат shared_ptr друг на друга, никогда не дойдут до refcount 0 — утечка. Замените одно направление на weak_ptr (наблюдает, не владея); доступ через wp.lock(), атомарно возвращающий shared_ptr или null.

realloc(ptr, newSize) меняет размер блока malloc/calloc на месте, если возможно, иначе выделяет новый блок, побайтово копирует и освобождает старый. При неудаче возвращает null, не освобождая исходный. В C++ безопасен только для тривиально перемещаемых типов — ctor/dtor не вызываются.

std::allocator<T> — это аллокатор по умолчанию, через который контейнеры получают и освобождают сырую память: allocate/deallocate ворочают байты, а конструирование — отдельный шаг. Собственный аллокатор пишут ради пулов, контроля выравнивания, размещения данных в аренах или shared memory либо инструментирования выделений.

Используйте Valgrind (--leak-check=full, без перекомпиляции), AddressSanitizer (-fsanitize=address, ~2x замедление, хорош для CI) или LeakSanitizer (-fsanitize=leak, только утечки и быстрее). На Windows: CRT debug heap или Dr. Memory.

Писать shared_ptr<T>(this) — создаётся новый control block, что ведёт к double-delete. enable_shared_from_this<T> добавляет скрытый weak_ptr, инициализируемый первым владеющим shared_ptr; shared_from_this() использует тот же control block или бросает bad_weak_ptr.

Логически ссылка — псевдоним; стандарт не диктует представление. На практике ссылки реализуются указателями — поле-ссылка добавляет размер указателя, ссылочный параметр передаётся как указатель. Компилятор может полностью их убрать.

Происходит, когда стек вызовов превышает лимит (обычно 1–8 МБ); ОС обнаруживает это через guard page и шлёт SIGSEGV. Частые причины: глубокая или бесконечная рекурсия, большие буферы на стеке. Предотвращение: ограничить рекурсию, заменить итерацией, перенести крупные буферы в кучу.

Выделите сырой выровненный буфер, используйте placement new для конструирования объектов в нём, явно вызывайте деструктор перед повторным использованием слота и никогда не вызывайте delete для указателя, полученного через placement new.

Ограничивайте сырые new/delete пользовательскими аллокаторами, RAII-обёртками и взаимодействием с C API. Не-владеющие наблюдатели могут оставаться сырыми — они не продлевают lifetime. Правило: владеющий сырой указатель сразу оборачивайте в умный.

SharedPtr<T> хранит указатель на объект и указатель на heap-allocated control block со счётчиком std::atomic<int>. Копирование инкрементирует, деструктор декрементирует и удаляет объект при достижении нуля.

WeakPtr<T> разделяет control block, но инкрементирует только weak count. lock() атомарно проверяет strong > 0 и увеличивает через CAS; возвращает пустой SharedPtr, если объект мёртв. Control block живёт до обнуления обоих счётчиков.

Они конструируют объекты в сырой памяти через placement new и откатывают частично сконструированные элементы при исключениях. Писать самому — при реализации контейнера: разделение allocate и construct даёт семантику reserve/resize.

Распространённые уязвимости C++: переполнение буфера, use-after-free, целочисленное переполнение, format string (printf(user_input)), double-free, гонки TOCTOU. Меры: RAII, умные указатели, ASan.

Используйте alignas(N) T x; для стека/static, std::aligned_alloc(N, size) с free (C++17) или operator new(size, std::align_val_t{N}) с соответствующим operator delete (C++17). Обычный new T выравнивает только по alignof(T).

Перегружают их ради пула мелких объектов, отслеживания выделений или контроля выравнивания. Определяют согласованной парой, членом класса или глобально; operator new принимает size_t и возвращает void* (бросая bad_alloc либо noexcept для nothrow-формы). Членская версия используется new T для этого класса и его наследников.

Классические аллокаторы — это параметры шаблона, поэтому vector<int,A> и vector<int,B> — разные типы, которые нельзя смешивать. polymorphic_allocator хранит указатель memory_resource*, выбираемый в рантайме, поэтому стратегия выделения меняется без смены типа контейнера и без раздувания шаблонов.

Контейнеры C++ НЕ используют realloc, поскольку он только побайтово копирует и не вызывает move-конструкторы или обновляет самореференцирующие указатели. std::vector выделяет новый блок, перемещает каждый элемент (или копирует, если move не noexcept), затем уничтожает оригиналы.