Top 50 C++ Interview Questions with Answers (2026): Beginner to C++ Expert

int x = 10;
int* ptr = &x; // ptr holds the memory address of x
cout << *ptr;  // Dereference: prints 10
cout << ptr;   // Prints: 0x7ffd4a2c (the address)

💡 Why Interviewers Ask This: It is the absolute foundation of C/C++. You cannot build a Linked List, a Tree, or implement dynamic memory allocation without understanding how to manipulate memory addresses. Every subsequent question in this interview builds on this one.

// C style — no constructor called
MyClass* p = (MyClass*) malloc(sizeof(MyClass));

// C++ style — constructor IS called
MyClass* p = new MyClass();
delete p; // destructor IS called

💡 Why Interviewers Ask This: Tests your transition from procedural C to object-oriented C++. The critical rule: never mix malloc with delete, or new with free — doing so is undefined behavior that corrupts the heap.

A Memory Leak occurs when you dynamically allocate memory on the heap (using new or malloc) but fail to release it (using delete or free) before the pointer goes out of scope. The memory becomes permanently trapped and unusable until the program restarts.

void leakyFunction() {
    int* arr = new int[1000]; // allocated on heap
    return; // pointer goes out of scope — memory NEVER freed
            // This is a 4KB memory leak every call!
}

💡 Why Interviewers Ask This: Memory leaks are the #1 cause of production server crashes in C++ applications. A long-running server that leaks 4KB per request will consume all available RAM after millions of requests and crash irreversibly.

A Dangling Pointer is a pointer that points to a memory location that has already been deleted or freed. Accessing or modifying a dangling pointer leads to undefined behavior — crashes, silent data corruption, or security vulnerabilities (use-after-free exploits).

int* ptr = new int(42);
delete ptr;
// BAD: ptr is now dangling — points to freed memory
*ptr = 10; // ← Undefined behavior: segfault or silent corruption

// GOOD: Always set to nullptr after deleting
ptr = nullptr;
*ptr = 10; // ← Now safely crashes with a clear NULL dereference error

💡 Why Interviewers Ask This: Proves you know how to safely manage memory lifecycles. Setting pointers to nullptr after deletion converts a silent, hard-to-debug use-after-free error into a clear, immediately obvious null-pointer dereference crash.

💡 Why Interviewers Ask This: When passing a massive vector into a recursive DFS function, passing by value will cause a Time Limit Exceeded (TLE) error due to copying thousands of elements on every single recursive call. Always use const vector<...>& instead.

nullptr is a type-safe keyword introduced in C++11 representing a null pointer constant. NULL is an older C-style macro that evaluates to the integer 0. This causes severe function overloading ambiguities:

void process(int x)   { cout << "int overload"; }
void process(int* x)  { cout << "pointer overload"; }

process(NULL);    // Ambiguous! NULL is 0 — calls the int overload!
process(nullptr); // Unambiguous — always calls the pointer overload ✓

💡 Why Interviewers Ask This: Modern C++ (C++11 and onwards) strictly prefers nullptr. Using it demonstrates you write modern, safe, unambiguous code and understand the type system.

Pointer Arithmetic allows mathematical operations on pointers. Adding 1 to an integer pointer does not add 1 byte; it advances the pointer by sizeof(int) (4 bytes) to the next array element. The compiler automatically scales the increment by the pointed-to type's size.

int arr[] = {10, 20, 30};
int* p = arr;    // Points to arr[0]

p++;             // Moves forward sizeof(int) = 4 bytes
cout << *p;      // 20 — arr[1]

// arr[i] is mathematically IDENTICAL to *(arr + i)
cout << arr[2];        // 30
cout << *(arr + 2);    // 30 ← same thing

💡 Why Interviewers Ask This: It is the underlying mechanism of how arrays work in C/C++. Square bracket notation arr[i] is compiler syntax sugar for *(arr + i). Understanding this is essential for writing custom memory allocators and embedded systems code.

In C++, the only functional difference is default member accessibility:

💡 Why Interviewers Ask This: DSA node types (Linked List Node, Tree Node, Graph Edge) are almost exclusively written using struct because you want direct public access to val, next, and left/right pointers without writing boilerplate getters and setters. A practical engineer uses the right tool for each job.

Using const auto& ensures you access each element by reference (preventing expensive memory copies of large objects) while enforcing that the data cannot be accidentally modified (const). It is the industry standard for iterating over containers.

// ❌ Bad: Copies every string in the vector (expensive!)
for (auto str : largeStringVector) { ... }

// ✅ Best: Reference to original, no copy, cannot mutate
for (const auto& str : largeStringVector) {
    cout << str << "\n";
}

💡 Why Interviewers Ask This: Shows you write performance-conscious, safe C++ code. In code reviews, for (auto x : vec) on a large object vector is a common performance bug. const auto& is the correct, idiomatic fix.

Smart Pointers are C++ RAII wrappers around raw pointers that automatically call delete when they go out of scope, completely eliminating memory leaks.

auto p = std::make_unique<int>(42); // heap memory
// p goes out of scope → delete called automatically
// NO memory leak, NO dangling pointer ✓

💡 Why Interviewers Ask This: In modern C++ roles (C++11 and beyond), raw new/delete are strongly discouraged in application code. Smart pointers are the default expectation for any heap allocation. If you only use raw pointers, you are not writing modern C++.

The Standard Template Library (STL) is a powerful library of generic template classes providing pre-built, highly optimized implementations of common data structures (Containers: vector, map, unordered_map, set, stack, queue, deque, priority_queue) and algorithms (Algorithms: sort, binary_search, lower_bound, max_element, accumulate).

💡 Why Interviewers Ask This: Re-inventing the wheel in an interview is the single biggest time waster. You must know when to use a ready-made STL container instead of implementing it from scratch, and you must justify your choice of container with its Big-O complexity characteristics.

💡 Why Interviewers Ask This: std::vector is the default data structure for 99% of C++ coding interviews. Understanding why (dynamic size, iterator support, STL algorithm compatibility) demonstrates foundational C++ fluency.

When a vector reaches its capacity, push_back:

💡 Why Interviewers Ask This: Tests knowledge of Amortized Time Complexity. While a specific resize is O(n), the amortized cost of each individual push_back over a sequence of n insertions is O(1). Call vec.reserve(n) when you know the size upfront to eliminate all reallocations entirely.

💡 Why Interviewers Ask This: The most frequently asked STL question. Every Two Sum, Frequency Counting, and Sliding Window problem uses unordered_map. Choosing map when you don't need sorted order is a performance mistake that will cause TLE on large inputs.

A Set stores a collection of unique elements (automatically rejects duplicates). std::set stores them sorted (Red-Black Tree, O(log n)), while std::unordered_set stores them unsorted (Hash Table, O(1) average). Best use case: instantly remove all duplicates from an array.

vector<int> nums = {1, 3, 2, 3, 1, 5};
unordered_set<int> s(nums.begin(), nums.end());
// s = {1, 2, 3, 5} — duplicates removed in one line, O(n)

💡 Why Interviewers Ask This: Sets are the optimal data structure for duplicate removal and membership testing. Coding problems that ask “find all unique elements” should instantly trigger your use of unordered_set.

// Max-Heap (default) — largest element at top
priority_queue<int> maxHeap;
maxHeap.push(3); maxHeap.push(1); maxHeap.push(5);
cout << maxHeap.top(); // 5

// Min-Heap — smallest element at top
priority_queue<int, vector<int>, greater<int>> minHeap;
minHeap.push(3); minHeap.push(1); minHeap.push(5);
cout << minHeap.top(); // 1

💡 Why Interviewers Ask This: You will never be asked to implement heapify() from scratch. You are expected to use priority_queue to solve “Find the Kth Largest Element,” “Top K Frequent Elements,” and “Merge K Sorted Lists.” The min-heap declaration syntax with greater<int> trips up many candidates.

vector<int> v;
v.reserve(1000);     // Pre-allocate capacity for 1000 elements
// v.size() = 0, v.capacity() = 1000
// Now 1000 push_backs will NEVER trigger a reallocation ✓

💡 Why Interviewers Ask This: Tests memory optimization awareness. Calling vec.reserve(n) when you know the number of insertions in advance eliminates all expensive O(n) copy-reallocations and makes memory usage predictable.

std::sort() uses a hybrid algorithm called IntroSort: it begins with QuickSort for cache-efficient average-case performance, but if the recursion depth exceeds a threshold (indicating a worst-case pivot sequence), it automatically switches to HeapSort, guaranteeing O(n log n) worst-case time complexity.

💡 Why Interviewers Ask This: Proves you understand that the STL is mathematically protected against the O(n²) worst-case failure of a naive QuickSort implementation. STL std::sort is always safe to use in production.

std::pair is a simple container that binds two heterogeneous values together as a single unit, accessed via .first and .second. Essential in graphs (edge destination + weight) and for returning two values from a function.

// Adjacency list: {neighbor, edge_weight}
vector<pair<int, int>> adj[10];
adj[0].push_back({1, 5}); // neighbor=1, weight=5

// Dijkstra min-heap: {distance, node}
priority_queue<pair<int,int>, vector<pair<int,int>>,
               greater<>> pq;
pq.push({0, source});

💡 Why Interviewers Ask This: Essential syntax for graph traversal problems. Dijkstra, Kruskal, and most graph problems on LeetCode store pair<int,int> in their priority queues or adjacency lists.

int main() {
    ios_base::sync_with_stdio(false); // Decouple C/C++ I/O streams
    cin.tie(NULL);                    // Untie cin from cout
    // Now cin/cout is ~5-10x faster for large input
}

This disables the synchronization between C (printf/scanf) and C++ (cin/cout) standard I/O streams. The combined sync, while convenient, adds significant overhead. After calling this, do not mix C and C++ I/O in the same program.

💡 Why Interviewers Ask This: Shows deep experience with fast-execution competitive coding environments (LeetCode, Codeforces). For problems requiring reading millions of integers, the difference is program-pass vs Time Limit Exceeded.

struct ListNode {
    int val;
    ListNode* next;
    ListNode(int x) : val(x), next(nullptr) {} // Constructor
};

// Usage
ListNode* head = new ListNode(1);
head->next     = new ListNode(2);
head->next->next = new ListNode(3);
// 1 → 2 → 3 → nullptr

💡 Why Interviewers Ask This: You must be able to write this from memory in a whiteboard interview — this is the exact ListNode definition used on LeetCode. Note the use of struct (public by default) and the member initializer list constructor.

Use three pointers: prev, current, and next. Iteratively reverse each node's next pointer to point backwards:

ListNode* reverseList(ListNode* head) {
    ListNode* prev = nullptr;
    ListNode* curr = head;
    while (curr != nullptr) {
        ListNode* next = curr->next; // 1. Save next
        curr->next = prev;           // 2. Reverse the link
        prev = curr;                 // 3. Advance prev
        curr = next;                 // 4. Advance curr
    }
    return prev; // prev is the new head
}

💡 Why Interviewers Ask This: This is the “Hello World” of pointer manipulation. It tests that you can manage multiple moving pointers simultaneously without losing track of nodes. Time: O(n), Space: O(1). If you cannot reverse a linked list, the interview typically ends here.

💡 Why Interviewers Ask This: C-string buffer overflows are a massive, historic security vulnerability. Modern C++ relies exclusively on std::string. Using char* without extreme care invites undefined behavior and security holes.

void deleteList(ListNode* head) {
    ListNode* curr = head;
    while (curr != nullptr) {
        ListNode* nextNode = curr->next; // Save next BEFORE deleting
        delete curr;                     // Free current node
        curr = nextNode;                 // Move to saved next
    }
    // head = nullptr; // Caller should nullify their pointer too
}

💡 Why Interviewers Ask This: Proves you know how to tear down data structures without memory leaks. The critical step: save curr->next to a temporary variable before calling delete — once deleted, accessing curr->next is a dangling pointer dereference.

Floyd's Cycle Detection uses a slow pointer (advances 1 step per iteration) and a fast pointer (advances 2 steps per iteration). Applications:

💡 Why Interviewers Ask This: The standard O(n) time, O(1) space solution for linked list topology problems. A hash-set approach to detect cycles exists but uses O(n) extra space — Floyd's is superior and the expected answer.

std::stack is a Container Adapter. It does not allocate memory itself; instead, it wraps an underlying container (by default, std::deque) and restricts its interface to LIFO operations only: push(), pop(), and top(). You can change the underlying container:

stack<int>               s;  // Uses deque internally (default)
stack<int, vector<int>>  s;  // Uses vector internally (faster if no dealloc)
stack<int, list<int>>    s;  // Uses linked list internally

💡 Why Interviewers Ask This: Deep STL knowledge. Understanding that stack is an adapter (not a standalone container) and knowing how to change its underlying storage demonstrates true C++ internals expertise.

Maintain two index variables: front and rear. Enqueue increments rear. Dequeue increments front. To prevent memory waste from a linearly shifting window, use modulo arithmetic (% capacity) to create a Circular Queue:

class CircularQueue {
    int* arr;
    int front = 0, rear = 0, size = 0, cap;
public:
    CircularQueue(int c) : cap(c) { arr = new int[c]; }
    void enqueue(int x) { arr[rear % cap] = x; rear++; size++; }
    int  dequeue()     { int v = arr[front % cap]; front++; size--; return v; }
};

💡 Why Interviewers Ask This: Tests your ability to build hardware-level circular data buffers used in OS scheduling queues, network packet buffers, and audio streaming ring buffers.

A Double-Ended Queue (std::deque) allows fast O(1) insertion and deletion at both the front and the back. Internally implemented as an array of fixed-size chunks (not a single contiguous block like vector), allowing efficient growth in both directions without reallocation.

deque<int> dq;
dq.push_back(3);  // O(1) — add to back
dq.push_front(1); // O(1) — add to front (vector cannot do this efficiently!)
dq.pop_front();   // O(1) — remove from front

💡 Why Interviewers Ask This: deque is the secret weapon for the “Sliding Window Maximum” problem (LeetCode #239). The monotonic deque maintains candidates in a sliding window efficiently because you need fast pop from both ends.

A Monotonic Stack maintains elements in strictly increasing or strictly decreasing order. When a new element violates the ordering rule, elements are popped from the top until the rule is satisfied.

// Next Greater Element using Monotonic Stack — O(n)
vector<int> nextGreater(vector<int>& nums) {
    int n = nums.size();
    vector<int> res(n, -1);
    stack<int> st; // stores indices
    for (int i = 0; i < n; i++) {
        while (!st.empty() && nums[st.top()] < nums[i]) {
            res[st.top()] = nums[i]; // Found next greater!
            st.pop();
        }
        st.push(i);
    }
    return res;
}

💡 Why Interviewers Ask This: It is the only way to solve “Next Greater Element,” “Largest Rectangle in Histogram,” and “Trapping Rain Water” in O(n) time. A brute-force O(n²) nested loop will TLE on large inputs.

Use two queues. For every push(x): enqueue x to q2, then dequeue all elements from q1 and enqueue them to q2, then swap q1 and q2. After each push, q1.front() is the most recently pushed element (top of stack). Time: push O(n), pop O(1).

💡 Why Interviewers Ask This: A classic constraints test that forces you to simulate LIFO behavior using strictly FIFO tools. This tests creative problem decomposition. The reverse problem (Queue using Stacks) is also a very common interview question.

struct TreeNode {
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};

// Build a tree:  3
//               / \
//              1   5
TreeNode* root = new TreeNode(3);
root->left     = new TreeNode(1);
root->right    = new TreeNode(5);

💡 Why Interviewers Ask This: The exact TreeNode definition used on LeetCode. It is the foundation for all tree traversal, construction, and path-finding questions. You must write this from memory.

Almost all interview graphs use an Adjacency List built with a vector of vectors:

int n = 5; // 5 nodes
vector<vector<int>> adj(n);
adj[0].push_back(1); // Edge 0 → 1
adj[0].push_back(2); // Edge 0 → 2
adj[1].push_back(3); // Edge 1 → 3

// For weighted graphs — use pair<int,int> {neighbor, weight}
vector<vector<pair<int,int>>> wadj(n);
wadj[0].push_back({1, 5}); // Edge 0→1 with weight 5

💡 Why Interviewers Ask This: An adjacency matrix costs O(V²) memory (prohibitive for large sparse graphs). An adjacency list costs O(V + E) — the optimal representation for sparse graphs which are the vast majority of real-world graphs.

void bfs(int start, vector<vector<int>>& adj, int n) {
    vector<bool> visited(n, false);
    queue<int> q;
    q.push(start);
    visited[start] = true;
    while (!q.empty()) {
        int node = q.front(); q.pop();
        cout << node << " ";
        for (int neighbor : adj[node]) {
            if (!visited[neighbor]) {
                visited[neighbor] = true;
                q.push(neighbor);
            }
        }
    }
}

💡 Why Interviewers Ask This: Standard algorithm for finding the Shortest Path in an unweighted graph or matrix (number of edges). BFS guarantees level-by-level exploration — the first time you reach a node is always via the shortest path.

void dfs(int node, vector<vector<int>>& adj,
         vector<bool>& visited) {
    visited[node] = true;
    cout << node << " ";
    for (int neighbor : adj[node]) {
        if (!visited[neighbor]) {
            dfs(neighbor, adj, visited); // Recursive call
        }
    }
}

💡 Why Interviewers Ask This: Foundation of connected components, topological sort, path finding, and cycle detection. DFS uses the call stack implicitly — which is why passing adj by const vector<vector<int>>& is critical (see Q40).

struct DSU {
    vector<int> parent, rank;
    DSU(int n) : parent(n), rank(n, 0) {
        iota(parent.begin(), parent.end(), 0); // parent[i] = i
    }
    int find(int x) { // Path compression
        if (parent[x] != x)
            parent[x] = find(parent[x]);
        return parent[x];
    }
    void unite(int x, int y) { // Union by rank
        int px = find(x), py = find(y);
        if (px == py) return;
        if (rank[px] < rank[py]) swap(px, py);
        parent[py] = px;
        if (rank[px] == rank[py]) rank[px]++;
    }
};

💡 Why Interviewers Ask This: DSU is required for Kruskal's Minimum Spanning Tree and cycle detection in undirected graphs. With path compression + union by rank, the amortized time per operation is effectively O(α(n)) — nearly constant.

vector<int> dijkstra(int src, vector<vector<pair<int,int>>>& adj, int n) {
    vector<int> dist(n, INT_MAX);
    priority_queue<pair<int,int>,
                   vector<pair<int,int>>,
                   greater<>> pq; // Min-heap: {dist, node}
    dist[src] = 0;
    pq.push({0, src});
    while (!pq.empty()) {
        auto [d, u] = pq.top(); pq.pop();
        if (d > dist[u]) continue; // Stale entry, skip
        for (auto [v, w] : adj[u]) {
            if (dist[u] + w < dist[v]) {
                dist[v] = dist[u] + w;
                pq.push({dist[v], v});
            }
        }
    }
    return dist;
}

💡 Why Interviewers Ask This: The ultimate pathfinding algorithm. Used in Google Maps, GPS routing, and network packet routing (OSPF). Time complexity with a min-heap: O((V + E) log V).

struct TrieNode {
    TrieNode* children[26];
    bool isEndOfWord = false;
    TrieNode() { fill(children, children+26, nullptr); }
};

void insert(TrieNode* root, const string& word) {
    TrieNode* cur = root;
    for (char c : word) {
        int i = c - 'a';
        if (!cur->children[i])
            cur->children[i] = new TrieNode();
        cur = cur->children[i];
    }
    cur->isEndOfWord = true;
}

💡 Why Interviewers Ask This: A Trie provides O(L) search, insert, and prefix matching (where L = word length), beating hash tables for prefix queries. Used in Google Autocomplete, spellcheckers, and IP routing tables.

void deleteTree(TreeNode* root) {
    if (!root) return;
    deleteTree(root->left);      // 1. Delete left subtree
    deleteTree(root->right);     // 2. Delete right subtree
    delete root;                 // 3. THEN delete this node
    // POST-ORDER: left → right → root
}

💡 Why Interviewers Ask This: You MUST use post-order traversal. If you delete the root first (pre-order), you immediately lose the memory addresses of its children — causing a massive memory leak. Delete children before parents, always.

A Segment Tree is a binary tree where each node stores the aggregate result (sum, min, max, GCD) of a specific range (segment) of an underlying array. It supports:

💡 Why Interviewers Ask This: Advanced topic that solves the problem where naive O(n) array scans are too slow for massive datasets with many queries. Competitive programming gold-standard for range query problems.

// ❌ BAD: Copies the ENTIRE graph on every recursive DFS call
void dfs(int node, vector<vector<int>> adj, ...) { ... }

// ✅ GOOD: Passes a single reference — zero copy cost
void dfs(int node, const vector<vector<int>>& adj, ...) { ... }

Passing a massive 2D vector by value creates a full deep copy of the entire graph in memory on every single recursive call. A graph with 100K nodes × average 10 edges = 1M integers per copy × potentially thousands of recursive calls = immediate stack/heap exhaustion.

💡 Why Interviewers Ask This: Crucial C++ memory optimization test. const& gives you read-only access with zero overhead. This is why you should always pass large containers by const& in recursive functions.

// Sort pairs by second element, descending
vector<pair<int,int>> vec = {{1,5},{3,2},{2,8}};
sort(vec.begin(), vec.end(),
    [](const pair<int,int>& a, const pair<int,int>& b) {
        return a.second > b.second; // true = a comes before b
    }
);
// Result: {2,8}, {1,5}, {3,2}

💡 Why Interviewers Ask This: Required for sorting intervals (merge intervals), greedy algorithms (activity selection), and problems involving custom orderings. The lambda must return true if the first argument should come before the second.

DP is an algorithmic paradigm that breaks a complex problem into simpler, overlapping subproblems and stores the results in an array to avoid recalculating them. Two approaches:

💡 Why Interviewers Ask This: DP is the most tested algorithmic paradigm at top-tier companies. It converts exponential O(2ⁿ) recursive Fibonacci into a O(n) linear solution. Recognizing overlapping subproblems is the key skill.

// Fibonacci with Memoization — O(n) vs O(2^n) naive
vector<int> memo(101, -1); // -1 = not yet computed

int fib(int n) {
    if (n <= 1) return n;
    if (memo[n] != -1) return memo[n]; // Cache hit!
    return memo[n] = fib(n-1) + fib(n-2); // Cache and return
}

💡 Why Interviewers Ask This: It is the “Top-Down” implementation of DP. The sentinel value -1 distinguishes “not computed” from a valid result of 0. Many candidates initialize memo to 0 and then wonder why caching doesn't work for problems where the answer can legitimately be 0.

// Longest substring with at most k distinct characters — O(n)
int lengthOfLongestSubstringKDistinct(string s, int k) {
    unordered_map<char,int> freq;
    int left = 0, maxLen = 0;
    for (int right = 0; right < s.size(); right++) {
        freq[s[right]]++;
        while (freq.size() > k) {    // Contract window
            if (--freq[s[left]] == 0)
                freq.erase(s[left]);
            left++;
        }
        maxLen = max(maxLen, right - left + 1);
    }
    return maxLen;
}

💡 Why Interviewers Ask This: The standard O(n) solution for all “find the longest/shortest subarray/substring satisfying a condition” problems. A brute-force O(n²) nested loop will TLE on large inputs under contest conditions.

int a = 5, b = 9;
a = a ^ b; // a = 5^9 = 12
b = a ^ b; // b = 12^9 = 5  (a XOR b XOR b = a)
a = a ^ b; // a = 12^5 = 9  (a XOR b XOR a = b)
// a = 9, b = 5 — swapped with zero extra memory!

The XOR trick relies on two XOR properties: X ^ X = 0 (self-cancellation) and X ^ 0 = X (identity). Warning: fails if a and b are the same variable (same memory address) — use std::swap() in production code.

💡 Why Interviewers Ask This: A classic bit-manipulation brain teaser and a great signal that you understand bitwise operations at a low level.

bool isPowerOfTwo(int n) {
    return n > 0 && (n & (n - 1)) == 0;
}
// 8  = 1000  →  n-1 = 0111  →  AND = 0000 ✓
// 6  = 0110  →  n-1 = 0101  →  AND = 0100 ✗
// 16 = 10000 →  n-1 = 01111 →  AND = 00000 ✓

A power of 2 has exactly one 1-bit in its binary representation. Subtracting 1 flips all bits from that position downward. Their bitwise AND is therefore always 0.

💡 Why Interviewers Ask This: Executes in O(1) hardware time. Understanding this trick requires intuition about how binary numbers work — it is a strong signal of low-level systems thinking.

// Generate all permutations of a vector
void backtrack(vector<int>& nums, vector<vector<int>>& result,
               int start) {
    if (start == nums.size()) {
        result.push_back(nums); // Found a complete permutation
        return;
    }
    for (int i = start; i < nums.size(); i++) {
        swap(nums[start], nums[i]);   // Choose
        backtrack(nums, result, start + 1); // Explore
        swap(nums[start], nums[i]);   // Undo (backtrack!)
    }
}

💡 Why Interviewers Ask This: The standard algorithm for solving Sudoku, N-Queens, Word Search, Subsets, and Permutations. The key pattern: Choose → Explore → Undo. The undo step is what separates backtracking from plain DFS.

// Lambda syntax: [capture](params) -> return_type { body }

// 1. Custom sort (capture nothing)
auto cmp = [](int a, int b) { return a > b; }; // sort descending
sort(v.begin(), v.end(), cmp);

// 2. Capture local variable by reference
int target = 7;
auto found = find_if(v.begin(), v.end(),
                     [&target](int x){ return x == target; });

// 3. Recursive DFS defined inside main() — clean scope
function<void(int)> dfs = [&](int node) {
    visited[node] = true;
    for (int nb : adj[node]) if (!visited[nb]) dfs(nb);
};

💡 Why Interviewers Ask This: Lambdas are essential modern C++11 fluency. Defining recursive DFS/BFS as a lambda inside main() avoids function parameter clutter and keeps algorithm logic scoped precisely where it is used.

// Manual implementation — O(log n)
int binarySearch(vector<int>& arr, int target) {
    int lo = 0, hi = arr.size() - 1;
    while (lo <= hi) {
        int mid = lo + (hi - lo) / 2; // Prevents integer overflow!
        if (arr[mid] == target) return mid;
        else if (arr[mid] < target) lo = mid + 1;
        else hi = mid - 1;
    }
    return -1;
}

// STL shortcuts on sorted containers:
bool found = binary_search(v.begin(), v.end(), 7);  // true/false
auto it1 = lower_bound(v.begin(), v.end(), 5); // first >= 5
auto it2 = upper_bound(v.begin(), v.end(), 5); // first >  5

💡 Why Interviewers Ask This: lower_bound and upper_bound save 10+ minutes of typing a manual binary search during a timed interview. Critically: use mid = lo + (hi-lo)/2 — the naive (lo+hi)/2 overflows when lo + hi > INT_MAX.

If your class manually manages dynamic memory (owns raw pointers), you must explicitly define these special member functions, because the compiler-generated defaults do a shallow copy (pointer copy) — leading to two objects pointing to the same heap memory and a catastrophic double-free:

💡 Why Interviewers Ask This: The ultimate C++ closing question. It proves you understand the full object-oriented memory lifecycle — from construction to copying to destruction — and can reason about resource ownership semantics at the language level.