C++ Interview Notes

Resource Acquisition Is Initialization — Bjarne’s badly-named technique. The actual mechanism is the inverse: destruction is resource release. Better name: “Scope-Bound Resource Management” (SBRM).

A class owns a resource. Construction acquires it; destruction releases it. The compiler guarantees destructors run when the object goes out of scope — whether normally, via return, or via exception unwinding.

class File {
    FILE* f;
public:
    explicit File(const char* path) : f(fopen(path, "r")) {
        if (!f) throw std::runtime_error("open failed");
    }
    ~File() { if (f) fclose(f); }
    File(const File&) = delete;
    File& operator=(const File&) = delete;
};

void process() {
    File log("/var/log/x");
    if (something) throw std::runtime_error("oops");
    // log closed automatically on either path
}

Members initialize in declaration order, regardless of init-list order. Destruction is reverse order. Bases before members. This matters when one member’s construction depends on another:

class Conn {
    SocketHandle sock;
    Encryptor enc;        // depends on sock
public:
    Conn(const std::string& host)
        : sock(host)
        , enc(sock) {}    // sock guaranteed constructed first
};

If you swap declarations, you read an uninitialized sock. Compilers warn (-Wreorder) but the bug is silent without warnings.

Move-only types are RAII done right:

class File {
    FILE* f;
public:
    File(File&& o) noexcept : f(o.f) { o.f = nullptr; }
    File& operator=(File&& o) noexcept {
        if (this != &o) { if (f) fclose(f); f = o.f; o.f = nullptr; }
        return *this;
    }
    ~File() { if (f) fclose(f); }
};

The moved-from object is left in a “destructible” state (its destructor must run cleanly).

Compile-time conversion using the type system’s rules. Allowed:

• Numeric conversions (int → double, double → int)
• Pointer up/down within a class hierarchy (downcast not checked at runtime — UB if wrong)
• void* to typed pointer
• Explicit conversions defined by the user (explicit operator T)
• enum to underlying integer and back

double d = static_cast<double>(42);
Base* b = ...;
Derived* d = static_cast<Derived*>(b);    // UB if b is not actually a Derived

Use for: “I know this conversion makes sense, do it.” Catches obviously wrong casts at compile time.

Adds or removes const/volatile. Doesn’t change the underlying object’s bits.

const int x = 5;
int& y = const_cast<int&>(x);
y = 10;                          // UB — x is actually const

Modifying an object originally declared const is UB. Useful only for:

• Calling a legacy C API that takes non-const but doesn’t actually modify.
• Forwarding to a const-correct overload from a non-const member.

Type-pun safely:

float f = 1.5f;
std::uint32_t bits = std::bit_cast<std::uint32_t>(f);

Requires sizeof(From) == sizeof(To) and both trivially-copyable. No UB.

Same as C-style cast for built-in types. Calls the constructor for class types. Often confused with construction.

int(3.5);              // C-style cast — same as (int)3.5
Widget(args);          // construction — same as Widget{args}

int n = 0x3F800000;
float f = *reinterpret_cast<float*>(&n);    // strict aliasing UB

int* is not allowed to alias a float. Use:

float f = std::bit_cast<float>(n);          // C++20, no UB
// or
float f; std::memcpy(&f, &n, sizeof f);     // pre-C++20 idiom

Widget w(args);

• Storage from the function’s stack frame.
• Constructor called immediately.
• Lifetime ends at the end of the enclosing scope.
• Destructor runs automatically on scope exit (including exceptions).
• No heap allocator involved. Effectively free.

operator new / operator delete are replaceable:

void* operator new(std::size_t n) {
    auto p = my_alloc(n);
    if (!p) throw std::bad_alloc{};
    return p;
}
void operator delete(void* p) noexcept { my_free(p); }

Per-class overrides:

class Pool {
    static void* operator new(std::size_t);
    static void  operator delete(void*);
};

This is how engines and games override allocation policy without changing application code.

Widget* p = new (std::nothrow) Widget(args);
if (!p) { /* allocation failed */ }

operator new(nothrow_t) returns null instead of throwing. Embedded code uses this when exceptions are disabled.

• Stack is automatic — no possibility of leak.
• std::unique_ptr<T> and std::make_unique<T>(args) wrap new + RAII.
• std::make_shared<T>(args) allocates control block + object together (one allocation).
• Raw new/delete should be rare in modern code; mostly for implementing the smart pointers themselves.

Calling ~T() — runs the destructor. Frees any resources the object held (closes files, frees heap-owned buffers, etc.). Does not release the storage occupied by the object itself.

delete p;
// equivalent to:
p->~T();
operator delete(p);

T* p = new T(args);
p->~T();             // destroy
new (p) T(other_args);  // re-construct in same storage
// strict aliasing nuance — see C++.13 std::launder

Reusing storage with a different effective type requires std::launder to avoid the optimizer assuming the old object still lives there.

template<class Alloc>
class my_vector {
    T* data;
    Alloc alloc;

    void destroy(T* p) {
        std::allocator_traits<Alloc>::destroy(alloc, p);   // calls ~T()
    }
    void deallocate(T* p, std::size_t n) {
        std::allocator_traits<Alloc>::deallocate(alloc, p, n); // frees storage
    }
};

destroy runs the destructor; deallocate frees the storage. Containers use these separately to support partial states (e.g., destruct the trailing element on pop_back without shrinking capacity).

class Derived : virtual Base { ... };

Means: “if multiple inheritance chains lead through me to Base, share a single Base subobject across all of them.” The base’s location relative to this depends on the most-derived type.

D d;
B* pb = &d;       // ok, no cost
A* pa = pb;       // needs vbptr lookup to get the actual A address

Casting up to a virtual base is not free — it consults the vbptr at runtime. Casting back down (dynamic_cast<D*>(pa)) is also more expensive than a non-virtual downcast.

• iostreams (the canonical example): basic_iostream : basic_istream, basic_ostream, both inherit basic_ios virtually.
• Interface classes with optional shared state.

Two pointers alias when they refer to overlapping storage. The compiler’s view of aliasing constrains what optimizations it can apply.

int n = 42;
float f = *reinterpret_cast<float*>(&n);   // UB

Even if the bit pattern is what you want, the read through a float* of memory whose dynamic type is int violates strict aliasing.

union U { float f; int i; };
U u; u.f = 1.5f;
int n = u.i;     // UB in C++ — only the active member may be read
                 // (C is more permissive)

This is a place where C and C++ differ. In C, reading the non-active member of a union for type-punning is permitted (with caveats). In C++, it’s UB by the letter of the standard — but most compilers do the obvious thing. Use bit_cast or memcpy for portability.

void add(int* a, int* b, int* c, size_t n) {
    for (size_t i = 0; i < n; ++i) c[i] = a[i] + b[i];
}

Compiler must assume a, b, c may alias. So it emits a runtime check version-splitting into “aliased” and “non-aliased” paths, or just scalar code. Mark __restrict__ or write a non-aliasing wrapper to get clean vectorization.

std::vector provides the strong exception guarantee for many operations: if an operation throws, the vector is left in the state it was in before the operation began.

vector reallocation uses std::move_if_noexcept(elem):

• If T’s move constructor is noexcept(true): move.
• Otherwise: copy.

template<class T>
class Slow {
    T data;
public:
    Slow(const Slow&) = default;
    Slow(Slow&&) /* not noexcept */ {}
};

template<class T>
class Fast {
    T data;
public:
    Fast(const Fast&) = default;
    Fast(Fast&&) noexcept {}
};

A vector<Slow<Big>> will copy during grow → 10× slower than vector<Fast<Big>> if Big has expensive copy.

Move semantics typically:

1. Steal a pointer/handle from the source.
2. Reset the source.

No allocation, no exception sources. So noexcept is the right and easy answer. Defaulting your move constructor is noexcept if all subobjects’ moves are.

• std::move_if_noexcept returns T&& if noexcept-movable, otherwise const T&.
• Many algorithms (std::variant visit, std::function SBO) have different code paths for noexcept types.
• terminate() is called if a noexcept function actually throws.

Minimum viable:

template<class T, class Deleter = std::default_delete<T>>
class unique_ptr {
    T* p;
    [[no_unique_address]] Deleter d;
public:
    explicit unique_ptr(T* p = nullptr) noexcept : p(p) {}
    ~unique_ptr() { if (p) d(p); }

    unique_ptr(const unique_ptr&) = delete;
    unique_ptr& operator=(const unique_ptr&) = delete;

    unique_ptr(unique_ptr&& o) noexcept
        : p(o.p), d(std::move(o.d)) { o.p = nullptr; }

    unique_ptr& operator=(unique_ptr&& o) noexcept {
        if (this != &o) {
            if (p) d(p);
            p = o.p; d = std::move(o.d);
            o.p = nullptr;
        }
        return *this;
    }

    T& operator*() const noexcept { return *p; }
    T* operator->() const noexcept { return p; }
    T* get() const noexcept { return p; }

    T* release() noexcept { T* r = p; p = nullptr; return r; }
    void reset(T* np = nullptr) noexcept {
        T* old = p; p = np;
        if (old) d(old);
    }
    explicit operator bool() const noexcept { return p != nullptr; }
};

Size = sizeof(T*) if Deleter is stateless (EBO via [[no_unique_address]]); larger if Deleter has state.

Control block layout:

shared_ptr<T>
  +-- ptr -> T*       (or aliased ptr)
  +-- ctrl -> control_block
                          +-- strong_count (atomic)
                          +-- weak_count   (atomic)
                          +-- deleter
                          +-- allocator
                          +-- optional in-place T storage (if make_shared)

Minimum viable:

struct control_block_base {
    std::atomic<long> strong{1};
    std::atomic<long> weak{1};       // owners + (strong > 0 ? 1 : 0)
    virtual void destroy() noexcept = 0;
    virtual void deallocate() noexcept = 0;
    virtual ~control_block_base() = default;
};

template<class T, class Deleter, class Alloc>
struct control_block : control_block_base {
    T* p;
    Deleter d;
    Alloc a;
    control_block(T* p, Deleter d, Alloc a) : p(p), d(std::move(d)), a(std::move(a)) {}
    void destroy() noexcept override { d(p); }
    void deallocate() noexcept override {
        using rebind = typename std::allocator_traits<Alloc>::template rebind_alloc<control_block>;
        rebind ra(a);
        std::allocator_traits<rebind>::destroy(ra, this);
        std::allocator_traits<rebind>::deallocate(ra, this, 1);
    }
};

template<class T>
class shared_ptr {
    T* p;
    control_block_base* ctrl;

    void acquire() noexcept {
        if (ctrl) ctrl->strong.fetch_add(1, std::memory_order_relaxed);
    }
    void release() noexcept {
        if (ctrl && ctrl->strong.fetch_sub(1, std::memory_order_acq_rel) == 1) {
            ctrl->destroy();
            if (ctrl->weak.fetch_sub(1, std::memory_order_acq_rel) == 1)
                ctrl->deallocate();
        }
    }
public:
    shared_ptr() noexcept : p(nullptr), ctrl(nullptr) {}
    template<class U>
    explicit shared_ptr(U* raw)
        : p(raw),
          ctrl(new control_block<U, std::default_delete<U>, std::allocator<U>>(
              raw, std::default_delete<U>{}, std::allocator<U>{}))
    {}

    shared_ptr(const shared_ptr& o) noexcept : p(o.p), ctrl(o.ctrl) { acquire(); }
    shared_ptr(shared_ptr&& o) noexcept : p(o.p), ctrl(o.ctrl) { o.p = nullptr; o.ctrl = nullptr; }

    shared_ptr& operator=(shared_ptr o) noexcept { swap(o); return *this; }

    ~shared_ptr() { release(); }

    void swap(shared_ptr& o) noexcept { std::swap(p, o.p); std::swap(ctrl, o.ctrl); }

    T& operator*() const noexcept { return *p; }
    T* operator->() const noexcept { return p; }
    T* get() const noexcept { return p; }
    long use_count() const noexcept { return ctrl ? ctrl->strong.load() : 0; }
};

make_shared<T>(args...) allocates one chunk holding both the control block and T:

[control_block_inplace][T data...]

Pros:

• Single allocation instead of two.
• Better locality.
• The “in-place” control block stores T directly; no separate pointer.

Cons:

• T’s storage is freed only when the last weak_ptr dies — because the storage backing T is shared with the control block. With shared_ptr(new T), the T storage is freed on last shared_ptr; the control block on last weak_ptr.
• Can’t use custom deleter.
• Memory footprint may stay live longer if you keep weak_ptrs around.

struct Big { int a, b; };
shared_ptr<Big> big = std::make_shared<Big>();
shared_ptr<int> alias(big, &big->a);   // shares ownership of Big, but ptr-> is to .a

When alias’s reference count hits zero, both big’s storage and alias’s view are deallocated together. Useful for sharing ownership of a sub-object.

struct Node {
    std::shared_ptr<Node> next;
};

auto a = std::make_shared<Node>();
auto b = std::make_shared<Node>();
a->next = b;
b->next = a;     // cycle — a and b never freed

Break with std::weak_ptr:

struct Node {
    std::weak_ptr<Node> next;   // back-pointer doesn't own
};

If an exception is propagating (stack unwinding is happening), and a destructor that runs as part of unwinding also throws, the runtime calls std::terminate(). The program dies.

struct Bad {
    ~Bad() noexcept(false) {
        throw std::runtime_error("dtor!");
    }
};

void f() {
    Bad b;
    throw std::runtime_error("outer");    // unwinding starts
    // ~b() runs during unwind; throws; terminate()
}

struct Logger {
    ~Logger() {
        if (std::uncaught_exceptions() > 0) {
            // we're being destroyed during exception propagation
        }
    }
};

std::uncaught_exceptions() (C++17) returns the count; lets you behave differently in a destructor depending on whether you’re in exceptional cleanup vs normal exit. Older std::uncaught_exception() (singular) returned bool but had subtle issues.

All standard library destructors are noexcept. Throw out of a vector::~vector()? terminate.

For each base ctor with signature (P...), the compiler synthesizes a derived ctor:

Derived(P... args) : Base(std::forward<P>(args)...) {}

Members of Derived are default-initialized.

• Wrapping a base type to add behavior without re-declaring its API
• Exception types that mirror parent’s constructors

• vtable (virtual function table): per-class array of function pointers, one per virtual method. Lives in .rodata.
• vptr (virtual pointer): per-object pointer to the appropriate vtable. Lives at the start of the object (typical Itanium ABI).

• Constructor entry: vptr set to current class’s vtable.
• Constructor body of Derived: by the time Derived’s ctor body runs, vptr has been changed to Derived’s vtable (Base’s was set earlier).

Consequence: calling a virtual function from a constructor does not dispatch to derived overrides. The vptr is still pointing at the base vtable.

struct Base {
    Base() { speak(); }         // calls Base::speak — even from Derived
    virtual void speak() {}
};
struct Derived : Base {
    void speak() override {}
};

Derived d;                       // prints Base::speak

Same applies in destructor: vptr is reset to base’s during base’s destructor, so virtual calls dispatch to base.

Per-class: vtable sized by virtual function count (small). Per-object: one pointer (8 bytes on 64-bit) for the vptr.

So a class with one int and a virtual function is 16 bytes (8 vptr + 4 int + 4 padding), not 4.

If the compiler can prove the dynamic type (e.g., Derived d; d.f(); — type known), it elides the vtable indirection. final helps:

class Dog final : public Animal { ... };

Now any Dog* is known to be exactly Dog, enabling direct calls and inlining.

Runtime-checked cast within a polymorphic class hierarchy. Requires the source type to have at least one virtual function (so the vptr exists for RTTI access).

struct Animal { virtual ~Animal() = default; };
struct Dog : Animal { void fetch(); };
struct Cat : Animal { void meow(); };

Animal* a = get_some_animal();
if (Dog* d = dynamic_cast<Dog*>(a)) {
    d->fetch();
}

Compilers store an RTTI table reachable from each vtable. The cast:

1. Read vptr from *p (already required by vtable).
2. Index into RTTI to get the type_info and inheritance graph.
3. Walk the graph to find a path from dynamic type to T.
4. Adjust this by accumulated offsets (multiple inheritance).
5. Return result.

Cost: ~10–50 ns for simple hierarchies, more for deep/multi-inheritance. There’s a typeid instruction too:

if (typeid(*a) == typeid(Dog))
    // a's dynamic type is exactly Dog

typeid is faster (just two pointer compares) but doesn’t handle inheritance — it requires exact type match.

• Plugin systems where a registered object may be one of several derived types.
• Visitor variants (though std::variant is usually better).
• Diagnostic tools that need to introspect types.

struct Animal {};
struct Dog : Animal {};

Animal* a = new Dog;
Dog* d = dynamic_cast<Dog*>(a);   // error: Animal not polymorphic