C++ Interview Help — AI for RAII, Move Semantics, Smart Pointers & Memory

1. Memory, RAII & smart pointers

Stack vs heap, RAII (resources tied to object lifetime), unique_ptr vs shared_ptr vs weak_ptr, and avoiding leaks and dangling pointers. "When would shared_ptr cause a cycle?" The AI gives the precise lifetime answer.

2. Move semantics & the rule of 5

Rvalue references, move constructors/assignment, std::move, copy-vs-move, and the rule of 3/5/0. The AI explains exactly when a move fires versus a copy — a frequent filter.

3. Polymorphism, templates & UB

Virtual functions and vtables, virtual destructors, templates and the STL, and common undefined behavior (use-after-free, signed overflow, iterator invalidation). The AI flags the UB interviewers plant in trick questions.

1. "What is RAII, and how do smart pointers use it?"

Tie the answer to lifetime: a resource is acquired in a constructor and released in the destructor, so cleanup is deterministic and exception-safe. std::unique_ptr and std::shared_ptr are RAII wrappers that delete in their destructor — name them as the everyday application.

2. "unique_ptr vs shared_ptr vs weak_ptr — when each?"

Default to unique_ptr for single ownership (zero overhead, move-only). Reach for shared_ptr only when ownership is genuinely shared — it adds an atomic reference count. Use weak_ptr to break a shared_ptr cycle (e.g. parent ↔ child) that would otherwise leak.

3. "Explain move semantics: when does a move fire instead of a copy?"

A move binds an rvalue (a temporary or a std::move-cast lvalue) to a move constructor or move-assignment, stealing the resource instead of deep-copying. Stress that std::move only casts to an rvalue — it moves nothing by itself — and that a moved-from object must stay valid but unspecified.

4. "What is the rule of 0/3/5?"

Rule of 0: design so the compiler-generated special members suffice (let members like unique_ptr manage resources). If you must write one of destructor, copy constructor, or copy assignment, write all three (rule of 3); add the move constructor and move assignment for the rule of 5. The point is to keep copy and move consistent.

5. "Why does a base class need a virtual destructor?"

Deleting a derived object through a base pointer when the base destructor is non-virtual is undefined behavior — only the base part is destroyed. Marking the destructor virtual routes through the vtable so the full derived destructor runs.

6. "Find the undefined behavior in this snippet."

Scan for lifetime bugs first: returning a reference or pointer to a local, use-after-free, double-free, or dereferencing a dangling iterator after the container reallocated. Name the specific UB and the fix (extend the lifetime, copy, or reserve) rather than just saying "it crashes."

7. "std::vector vs std::list vs std::map vs unordered_map — complexity and when?"

vector gives O(1) amortized push_back and cache-friendly contiguous storage; list gives O(1) splice but poor locality; map is an ordered tree at O(log n); unordered_map is a hash table at O(1) average, O(n) worst. Tie the choice to access pattern and whether ordering matters.

How to prepare for a C++ interview

• Drill the rule of 0/3/5 by hand-writing a small RAII wrapper (a buffer or file handle) with correct copy and move members, then delete the ones you don't want.
• Compile with -Wall -Wextra -fsanitize=address,undefined so AddressSanitizer and UBSan catch the use-after-free and dangling-reference bugs interviewers plant.
• Practice reasoning about const-correctness and when to pass by const& vs by value vs by rvalue reference — a frequent follow-up to any function-signature question.
• Solve DS&A in modern, idiomatic C++ (range-based for, STL algorithms, auto) and be ready to state container complexity, since C++ rounds expect both the algorithm and the right container.

Pair this with broader coding interview help, the dynamic programming patterns guide, and our NVIDIA interview help for systems-heavy C++ roles.