Advanced C++ Interview Questions: Master Coding Patterns

C++ remains a powerhouse in systems programming, game development, and high-frequency trading. In advanced interviews, you're expected to go beyond syntax and demonstrate deep understanding of memory management, object-oriented design, and performance optimization. This guide covers the most challenging C++ interview questions, complete with solutions, time/space complexity, and insider tips. Whether you're interviewing at a FAANG company or a startup building real-time systems, mastering these patterns will set you apart. We'll explore RAII, move semantics, virtual tables, STL internals, and concurrency patterns. Each question includes a step-by-step breakdown and the reasoning interviewers want to hear. Let's dive into the advanced C++ landscape.

1. RAII and Smart Pointers

RAII (Resource Acquisition Is Initialization) is a cornerstone of C++ resource management. It ties resource lifetime to object lifetime. Smart pointers (std::unique_ptr, std::shared_ptr, std::weak_ptr) automate memory management. Interviewers often ask about ownership semantics, circular references, and custom deleters.

Example: Implement a simple unique_ptr-like class.

Key points: unique_ptr is move-only, shared_ptr uses reference counting, weak_ptr breaks cycles. Always prefer std::make_unique and std::make_shared for exception safety.

#include <iostream>
#include <memory>

class Resource {
public:
    Resource() { std::cout << "Resource acquired\n"; }
    ~Resource() { std::cout << "Resource released\n"; }
    void doWork() { std::cout << "Working...\n"; }
};

void useResource() {
    std::unique_ptr<Resource> ptr = std::make_unique<Resource>();
    ptr->doWork();
    // Automatically deleted when ptr goes out of scope
}

int main() {
    useResource();
    return 0;
}

2. Move Semantics and Perfect Forwarding

Move semantics allow transferring resources without copying, improving performance. std::move casts to an rvalue reference, enabling move constructors and move assignment operators. Perfect forwarding (std::forward) preserves value category in templates.

Example: Implement a move constructor for a custom String class.

Interviewers test understanding of lvalues, rvalues, and when move is triggered. Key: after a move, the source object is in a valid but unspecified state.

#include <iostream>
#include <cstring>

class MyString {
public:
    MyString(const char* s) : size(strlen(s)), data(new char[size+1]) {
        strcpy(data, s);
    }
    // Move constructor
    MyString(MyString&& other) noexcept : size(other.size), data(other.data) {
        other.size = 0;
        other.data = nullptr;
    }
    ~MyString() { delete[] data; }
private:
    size_t size;
    char* data;
};

int main() {
    MyString a("Hello");
    MyString b = std::move(a); // move constructor
    return 0;
}

3. Virtual Functions and Polymorphism

Virtual functions enable dynamic dispatch via the vtable. Each polymorphic class has a vtable pointer (vptr). Interviewers ask about virtual destructors, pure virtual functions, and slicing.

Example: Design a shape hierarchy with virtual area() method.

Key: virtual destructor ensures proper cleanup of derived objects. Slicing occurs when assigning a derived object to a base by value. Use pointers/references to avoid.

#include <iostream>

class Shape {
public:
    virtual double area() const = 0; // pure virtual
    virtual ~Shape() = default; // virtual destructor
};

class Circle : public Shape {
public:
    Circle(double r) : radius(r) {}
    double area() const override { return 3.14159 * radius * radius; }
private:
    double radius;
};

int main() {
    Shape* shape = new Circle(5.0);
    std::cout << "Area: " << shape->area() << std::endl;
    delete shape;
    return 0;
}

4. STL Containers and Algorithms

The Standard Template Library (STL) provides containers (vector, list, map, unordered_map) and algorithms (sort, find, accumulate). Interviewers test iterator invalidation, complexity guarantees, and custom comparators.

Example: Remove duplicates from a vector while preserving order.

Key: std::unordered_set for O(1) lookup; std::remove_if with erase-remove idiom.

#include <iostream>
#include <vector>
#include <unordered_set>
#include <algorithm>

std::vector<int> removeDuplicates(const std::vector<int>& input) {
    std::unordered_set<int> seen;
    std::vector<int> result;
    for (int x : input) {
        if (seen.insert(x).second) {
            result.push_back(x);
        }
    }
    return result;
}

int main() {
    std::vector<int> v = {1, 2, 3, 2, 1, 4};
    auto res = removeDuplicates(v);
    for (int x : res) std::cout << x << " ";
    return 0;
}

5. Concurrency and Threading

C++11 introduced std::thread, std::mutex, std::lock_guard, and std::async. Interviewers test deadlock prevention, data races, and lock-free programming.

Example: Implement a thread-safe counter.

Key: Use std::atomic for simple counters; std::mutex for complex critical sections. Avoid deadlock by locking mutexes in a consistent order.

#include <iostream>
#include <thread>
#include <mutex>
#include <vector>

class Counter {
public:
    void increment() {
        std::lock_guard<std::mutex> lock(mtx);
        ++value;
    }
    int get() const {
        std::lock_guard<std::mutex> lock(mtx);
        return value;
    }
private:
    mutable std::mutex mtx;
    int value = 0;
};

int main() {
    Counter counter;
    std::vector<std::thread> threads;
    for (int i = 0; i < 10; ++i) {
        threads.emplace_back([&counter]() {
            for (int j = 0; j < 1000; ++j) counter.increment();
        });
    }
    for (auto& t : threads) t.join();
    std::cout << "Final count: " << counter.get() << std::endl;
    return 0;
}

6. Template Metaprogramming

Template metaprogramming (TMP) performs computations at compile time. Interviewers may ask about SFINAE, type traits, and variadic templates.

Example: Implement a compile-time factorial using templates.

Key: TMP can reduce runtime overhead but increases compile time and code complexity. Use constexpr where possible for simpler compile-time evaluation.

#include <iostream>

template<int N>
struct Factorial {
    static constexpr int value = N * Factorial<N-1>::value;
};

template<>
struct Factorial<0> {
    static constexpr int value = 1;
};

int main() {
    std::cout << "Factorial of 5: " << Factorial<5>::value << std::endl;
    return 0;
}