C++ Interview Topics: Smart Pointers, Memory Management, Polymorphism, and More

The article begins with an introduction to a C++ interview session, outlining the need to assess understanding of fundamentals, object‑oriented programming, templates, and the STL.

Smart Pointer Implementation

It explains the original std::auto_ptr and its drawbacks, then walks through a step‑by‑step custom implementation of a basic smart pointer ( MyAutoPtr ) that provides automatic destruction, dereference operators, copy‑construction, and assignment handling.

template
class MyAutoPtr {
public:
    MyAutoPtr(T *ptr): _ptr(ptr) {}
    ~MyAutoPtr() { delete _ptr; }
    T* get() const { return _ptr; }
    T& operator*() { return *_ptr; }
    T* operator->() { return _ptr; }
private:
    T* _ptr;
};

Further improvements add proper copy‑construction and move semantics to avoid double‑deletion and resource leaks.

Memory Management and RAII

The text emphasizes RAII (Resource Acquisition Is Initialization) as a core C++ technique: resources are acquired in constructors and released in destructors, ensuring deterministic cleanup even when exceptions occur. It highlights std::unique_ptr and std::shared_ptr as standard RAII‑based smart pointers.

#include
std::unique_ptr
p(new MyClass);
std::shared_ptr
s = std::make_shared
();

Object‑Oriented Features

Polymorphism is described through virtual functions and vtables. A base class with a virtual display() method is overridden in derived classes, and dynamic binding selects the correct implementation at runtime.

class Base { public: virtual void display() { std::cout << "Base"; } };
class Derived : public Base { public: void display() override { std::cout << "Derived"; } };
Base* p = new Derived();
p->display(); // prints "Derived"

STL Containers

The article briefly covers std::vector growth strategy (doubling capacity) and the internal structure of std::map (red‑black tree) versus std::unordered_map (hash table), explaining why the standard library chooses red‑black trees for ordered maps.

Thread Synchronization

Common synchronization primitives are listed: mutexes, condition variables, semaphores, barriers, and atomic operations. The differences between std::lock_guard (simple scoped lock) and std::unique_lock (flexible, supports condition variables) are highlighted.

Modern C++ Features

Right‑value references and move semantics are introduced, showing how std::move transfers ownership without copying. A coroutine example demonstrates C++20's co_yield and co_await syntax for generator‑style code.

#include
struct generator {
    struct promise_type {
        int current;
        auto get_return_object() { return generator{handle.from_promise(*this)}; }
        auto initial_suspend() { return std::suspend_always{}; }
        auto final_suspend()   { return std::suspend_always{}; }
        void return_void() {}
        auto yield_value(int v) { current = v; return std::suspend_always{}; }
    };
    // ... implementation omitted for brevity ...
};

generator simple() {
    co_yield 1; co_yield 2; co_yield 3;
}

Overall, the article serves as a dense reference for C++ interview preparation, covering classic pitfalls (e.g., dangling pointers, copy‑elision issues) and modern language facilities.