C++ Object-Oriented & STL Interview Preparation Guide

std::unique_ptr enforces strict exclusive ownership semantics, meaning the managed heap resource cannot be copied or shared; it can only be moved to another unique_ptr. In contrast, std::shared_ptr implements shared ownership utilizing an atomic reference counter stored in a control block, allowing multiple pointers to reference the same resource. While shared_ptr provides flexibility, it introduces slight atomic increment/decrement overhead and increases memory footprint due to the control block, whereas unique_ptr imposes zero runtime overhead compared to a raw pointer.

When an exception is thrown during stack unwinding—such as when an existing exception is active and a destructor throws another exception while cleaning up local stack variables—the C++ runtime immediately invokes std::terminate, crashing the entire application without recovery. Destructors should always be marked noexcept to guarantee that resource cleanup completes safely even in the presence of error states. If cleanup operations can fail, those operations must be handled explicitly before the object enters its destruction phase.

When a class declares at least one virtual function, the compiler inserts a hidden pointer (vptr) inside every object instance of that class. This vptr points to a static, per-class virtual method table (v-table) containing function pointers to the correct virtual method implementations. When a virtual function is invoked via a base class pointer or reference, the CPU performs an indirect jump by looking up the function address in the v-table at runtime. This enables polymorphic dispatch but introduces minor CPU cache overhead and prevents aggressive compiler inlining.

Iterator invalidation occurs when operations on an STL container alter its underlying memory layout or node structure, rendering existing iterators, pointers, or references dangling. For example, calling push_back() on a std::vector when capacity is exceeded triggers reallocation of the entire underlying array to a new memory block. Developers prevent invalidation by pre-allocating memory using reserve() before bulk insertions, using node-based containers when iterator stability is mandatory, or updating iterator references returned by insertion and erasure methods.

Rvalue references, denoted by the && declarator, bind to temporary (rvalue) objects that are about to be destroyed. Move semantics leverage rvalue references to 'steal' internal heap resources (such as char* pointers or vector data buffers) from temporary objects rather than performing expensive deep heap copies. This drastically reduces CPU cycles and memory allocations when passing temporaries, returning large objects from functions, or resizing standard containers.

An engineer should almost always default to std::vector because its contiguous memory layout maximizes CPU data prefetching and L1/L2 cache locality. Although std::list provides O(1) insertions and deletions anywhere without reallocation, its scattered heap nodes cause severe cache thrashing and pointer chasing, making it substantially slower in practice for the vast majority of production workloads.

The Rule of Three states that if a class requires a custom destructor, copy constructor, or copy assignment operator, it almost certainly requires all three. The Rule of Five extends this to modern C++ by adding the move constructor and move assignment operator. The Rule of Zero states that classes should design their member variables using RAII wrappers (like smart pointers and STL containers), allowing the compiler to automatically generate all special member functions cleanly without requiring custom boilerplate.

Default system allocators (malloc/new) acquire memory from the global heap and utilize locks to ensure thread safety, which introduces unpredictable latency spikes and memory fragmentation. Custom allocators—such as arena, pool, or stack allocators—pre-allocate large contiguous memory blocks up front and service individual object requests in constant time with zero global lock contention, ensuring deterministic sub-microsecond performance.

The Pimpl (Pointer to Implementation) idiom is a design technique where a class hides its private member variables and implementation details behind a forward-declared pointer to an internal struct. This decouples the public header file from private header dependencies, ensuring that modifying private implementation details does not trigger cascading recompilation across dependent translation units, significantly reducing build times.

Dynamic polymorphism relies on runtime virtual tables (v-tables) and pointer indirection, enabling heterogeneous container storage and runtime type flexibility at the cost of slight dispatch overhead and inhibited inlining. Static polymorphism uses the Curiously Recurring Template Pattern (CRTP) or templates to resolve function calls at compile time, enabling aggressive compiler optimization, zero runtime v-table overhead, and maximum execution speed, but sacrificing runtime type flexibility.

Object slicing occurs when a derived class object is assigned or passed by value to a base class variable or parameter, copying only the base class subobject and discarding the derived class members and vptr overrides. Object slicing is avoided by always passing and storing polymorphic objects through pointers or smart pointers (e.g., std::unique_ptr<Base>) rather than by value.

std::make_unique is exception-safe and concise, eliminating the need to explicitly write the new keyword. Furthermore, when using std::make_shared, it combines the allocation of the control block and the object into a single continuous memory block, reducing heap fragmentation and improving cache efficiency compared to separate allocations.