Memory

delete frees one object and calls its destructor once; delete[] frees a new[] array and calls the destructor for every element. Mismatching them is undefined behaviour and may corrupt heap metadata, skip destructors, or crash.

A memory leak is dynamically allocated memory that is never freed; if delete is omitted, the destructor never runs and the heap block stays allocated, eventually causing OOM in long-running processes.

new allocates storage and constructs an object; delete calls the destructor and releases storage. malloc/free only allocate and free raw bytes and know nothing about constructors, destructors, or C++ types.

A pointer stores the address of an object; its size is platform-dependent (8 bytes on 64-bit) regardless of the pointed-to type. Operations: *p, &x, p->m. Arithmetic is defined only inside arrays: p + n advances by n * sizeof(*p) bytes.

Resource Acquisition Is Initialization: acquire a resource in the constructor, release it in the destructor. C++ guarantees destructor calls during stack unwinding, so RAII makes cleanup automatic and exception-safe.

Stack allocation is automatic, LIFO, and bounded (typically 1–8 MB); deallocation happens when the scope exits. Heap allocation is manual or via smart pointers, effectively unbounded, but incurs allocator overhead and can fragment.

unique_ptr has exclusive ownership and is move-only. shared_ptr has shared ownership through a control block with reference counters. weak_ptr observes the same control block without extending lifetime and is used to break cycles or test whether the object is still alive.

malloc(size) allocates uninitialised bytes; calloc(count, size) allocates count * size bytes, zero-initialises them, and checks the multiplication for overflow. Both must be paired with free, never delete.

Zero-overhead RAII wrapper that exclusively owns a heap object — non-copyable but movable. On destruction or reset it calls delete (or a custom deleter). Ownership transfers explicitly via std::move(up).

Alignment requires a type's address to be a multiple of its alignof (e.g., int at a 4-byte boundary). The compiler inserts padding so struct size != sum of members. Misaligned access faults on strict CPUs and adds bus transactions elsewhere.

Writing past the allocated region corrupts adjacent memory: on the stack this overwrites the return address (stack smashing); on the heap it corrupts allocator metadata. Detect with AddressSanitizer, Valgrind, or stack canaries.

Double-free is undefined behaviour: it corrupts the heap metadata stored next to allocations and can crash, silently corrupt data, or create a security vulnerability. AddressSanitizer (-fsanitize=address) detects it instantly at runtime.

If doWork throws, delete[] buf is skipped during stack unwinding, so the buffer leaks — manual new/delete is not exception-safe. Fix with RAII: std::vector<int> buf(1000); or auto buf = std::make_unique<int[]>(1000);, freed automatically while unwinding.

make_shared<T>(args) does a single heap allocation for both object and control block, while shared_ptr<T>(new T) does two. It is faster, has better cache locality, and eliminates the exception-safety leak when arguments throw between new and the shared_ptr ctor.

Undefined behavior: memory from new[] must be released with delete[], not delete. Mismatching them is UB — typically a leak or heap corruption. Fix: write delete[] arr, or avoid raw arrays via std::vector<int> or std::make_unique<int[]>(100).

A heap-allocated structure storing strong refcount, weak refcount, deleter, and allocator; both shared_ptr and weak_ptr point to it. The object is destroyed when strong count hits 0; the control block survives until weak count also hits 0.

Access after delete is undefined behavior. It may crash, appear to work, read stale data, corrupt another object, or fail later. The allocator is allowed to reuse that block immediately, and the language gives no guarantees.

Cycles where A and B hold shared_ptr to each other never reach refcount 0 — leak. Replace one direction with weak_ptr (observes without owning); access via wp.lock() which atomically returns a shared_ptr or null.

realloc(ptr, newSize) resizes a malloc/calloc block in place if possible, otherwise allocates a new block, byte-copies, and frees the old one. On failure returns null without freeing the original. Safe in C++ only for trivially relocatable types — no ctors/dtors are called.

std::allocator<T> is the default allocator containers use to obtain and release raw storage: allocate/deallocate move bytes while construction is a separate step. You write a custom allocator to pool memory, control alignment, place data in arenas or shared memory, or instrument allocation.

Use Valgrind (--leak-check=full, no recompilation needed), AddressSanitizer (-fsanitize=address, ~2x slowdown, ideal for CI), or LeakSanitizer (-fsanitize=leak, leak-only and faster). On Windows: CRT debug heap or Dr. Memory.

Writing shared_ptr<T>(this) creates a new control block — leading to double-delete. enable_shared_from_this<T> adds a hidden weak_ptr initialised when the first shared_ptr takes ownership; shared_from_this() reuses that control block, throwing bad_weak_ptr otherwise.

Logically a reference is an alias; the standard does not mandate a representation. In practice references are implemented as pointers — a reference member adds one pointer of storage, a reference parameter is passed as a pointer. The compiler may elide them entirely.

Occurs when the call stack exceeds its limit (typically 1–8 MB); the OS detects it via a guard page and sends SIGSEGV. Common causes: deep or infinite recursion, large stack buffers. Prevention: bound recursion, convert to iteration, move large buffers to the heap.

Allocate a raw aligned buffer, use placement new to construct objects into it, call the destructor explicitly before reusing the slot, and never call delete on a placement-new pointer.

Limit raw new/delete to custom allocators, RAII wrappers, and C-API interop. Non-owning observers may stay raw — they do not extend lifetime. Rule of thumb: owning raw pointers must be wrapped in a smart pointer immediately.

SharedPtr<T> holds the object pointer plus a pointer to a heap-allocated control block with an std::atomic<int> reference count. Copy increments it; destructor decrements and deletes the object when it reaches zero.

WeakPtr<T> shares the control block but increments only the weak count. lock() atomically checks strong > 0 and increments it via CAS; returns empty SharedPtr if the object is dead. The control block survives until both counts hit zero.

They construct objects in raw memory via placement new and roll back partially-constructed elements on exceptions. You write them yourself when implementing a container — separating allocate from construct enables reserve/resize semantics.

Common C++ vulnerabilities: buffer overflow, use-after-free, integer overflow, format string (printf(user_input)), double-free, TOCTOU races. Mitigations: RAII, smart pointers, ASan, stack canaries.

Use alignas(N) T x; for stack/static, std::aligned_alloc(N, size) with free (C++17), or operator new(size, std::align_val_t{N}) with matching operator delete (C++17). Plain new T aligns only to alignof(T).

Overload them to pool small objects, track allocations, or enforce alignment. Define them as a matching pair, member or global; operator new takes size_t and returns void* (throwing bad_alloc or being noexcept for the nothrow form). A class member version is used by new T for that type and its derived classes.

Classic allocators are template parameters, so vector<int,A> and vector<int,B> are different types that cannot interoperate. polymorphic_allocator holds a runtime memory_resource* pointer, so allocation strategy is chosen at runtime without changing the container type or causing template bloat.

C++ containers do NOT use realloc because it only byte-copies and cannot call move constructors or fix self-referential pointers. std::vector allocates a new block, move-constructs each element (or copies if move is not noexcept), then destroys originals.