Interview questions by language
Memory management, RAII, smart pointers, move semantics, and the STL.
What it really tests
A C++ interview goes where managed languages cannot: manual memory, deterministic destruction, and the zero-overhead principle that you pay only for what you use. The foundational topic is memory and ownership. Interviewers want to see that you think in terms of RAII (Resource Acquisition Is Initialisation), where a resource's lifetime is tied to an object's scope, and that you reach for smart pointers (unique_ptr, shared_ptr) over raw new/delete. A candidate still calling delete by hand in modern C++ raises a flag.
The second theme is the value semantics that make C++ both powerful and treacherous: copy constructors, the assignment operator, move semantics, and the Rule of Three/Five/Zero. Move semantics (introduced in C++11) is a favourite, because understanding when a move happens, what std::move actually does (it is just a cast to an rvalue reference), and why moves avoid expensive copies demonstrates real modern-C++ fluency. The Rule of Zero, letting the compiler generate the special members by relying on RAII members, is the idiom seniors prefer.
The third theme is the STL and templates. You should know the containers and their complexity (vector vs list vs map vs unordered_map), the iterator model, and the algorithms header. Template questions probe whether you understand compile-time polymorphism and, at senior level, things like template specialisation and the cost model. Throughout, interviewers test for undefined behaviour awareness: dangling references, use-after-free, and iterator invalidation are the bugs C++ punishes hardest.
C++ is the interview language for systems, gaming, HFT, embedded, and performance-critical backend roles across the US and EU; loops are deep on manual memory, RAII, and the cost of every abstraction.
The map
Stack vs heap, RAII, smart pointers (unique_ptr, shared_ptr, weak_ptr), and why manual new/delete is discouraged in modern C++.
Copy vs move, the Rule of Three/Five/Zero, what std::move does, and when the compiler elides copies. The defining modern-C++ topic.
Containers and their complexity, iterators and invalidation, and the algorithms header. The everyday toolkit interviewers expect fluency in.
Dangling pointers, use-after-free, iterator invalidation, and data races. C++ trusts you, so awareness of UB is a core seniority signal.
Question bank
The questions that come up most often, each with a sample answer you can adapt into your own words. Read them out loud until the explanation feels natural.
RAII (Resource Acquisition Is Initialisation) ties a resource's lifetime to an object's scope: the constructor acquires the resource and the destructor releases it, so cleanup happens automatically when the object goes out of scope, even on an exception. It is the foundation of safe C++: file handles, locks, and memory are wrapped in objects so you never leak them. Smart pointers and std::lock_guard are RAII in action.
unique_ptr expresses sole ownership: it cannot be copied, only moved, and it frees its object when it goes out of scope, with zero overhead over a raw pointer. shared_ptr expresses shared ownership via a reference count; the object is freed when the last shared_ptr is destroyed, at the cost of an atomic counter. Prefer unique_ptr by default and use shared_ptr only when ownership is genuinely shared; break reference cycles with weak_ptr.
Move semantics let you transfer a resource (like a heap buffer) from one object to another instead of copying it, by stealing the source's internals and leaving it in a valid empty state. std::move does not move anything itself; it is a cast that turns an lvalue into an rvalue reference so the move constructor or move assignment is selected. It is essential for returning large objects cheaply and for storing move-only types like unique_ptr in containers.
The Rule of Three says that if a class needs a custom destructor, copy constructor, or copy assignment, it almost certainly needs all three, because it manages a resource. The Rule of Five extends this to also include the move constructor and move assignment in modern C++. The Rule of Zero is the preferred goal: design classes so they need none of these by holding RAII members (smart pointers, containers) that manage their own resources.
A reference is an alias for an existing object: it must be initialised, cannot be null, and cannot be reseated to refer to something else. A pointer is a variable holding an address: it can be null, can be reassigned, and supports arithmetic. Use a reference when the binding is fixed and the object always exists; use a pointer when it may be null or needs to change what it points to.
Iterator invalidation is when an operation on a container makes existing iterators (or pointers/references into it) invalid, so using them is undefined behaviour. For example, vector::push_back may reallocate the backing array, invalidating all iterators; erasing from a vector invalidates iterators at and after the erased point. You must know each container's rules and refresh iterators after modifying operations, often by using the return value of erase.
Use vector by default: contiguous storage gives O(1) random access and excellent cache locality, with amortised O(1) append. Use list (a doubly linked list) only for frequent middle insertions/removals where you already hold the position, accepting poor cache behaviour. Use unordered_map for average O(1) key-value lookup by hash; use map (a balanced tree) when you need sorted order or O(log n) worst case.
A virtual function enables runtime polymorphism: a call through a base-class pointer or reference dispatches to the derived class's override. It works via a vtable, a per-class table of function pointers, and a vptr in each object that points to it, so the right function is chosen at runtime. A class with virtual functions should have a virtual destructor, otherwise deleting a derived object through a base pointer is undefined behaviour.
Avoid these
The plan
An external resource we recommend. Educative is not affiliated with us and we earn nothing from this link.
Apply it to a role
Keep exploring
Language fluency gets you through the screen. Pair it with the coding interview patterns, rehearse the behavioral round with worked STAR answers, and when the offer comes, check it is competitive with the salary comparison tool.