C++ is asked in interviews for product companies, game development, embedded systems, finance and competitive programming. These C++ interview questions cover OOP, references and constructors for freshers, then virtual functions, memory management, smart pointers, move semantics, templates, the STL and modern C++ for experienced developers.
30 questions · Updated
Fundamentals, definitions and simple scenarios. Good for freshers and warm-ups.
C is a procedural language.
C++ adds object-oriented programming with classes, inheritance and polymorphism, plus references, function and operator overloading, templates, exceptions, namespaces and the Standard Template Library.
C++ is mostly compatible with C, but adds features for building large, abstract and type-safe programs.
A pointer stores an address, can be null, can be reassigned to point elsewhere and needs * to access the value.
A reference is an alias for an existing variable, must be initialised when declared, cannot be null or reseated, and is used like the variable itself.
References are preferred for function parameters when null is not a valid value.
A constructor is a special member function that initialises an object when it is created; it has the class name and no return type, and can be default, parameterised or a copy constructor. A destructor, named ~ClassName, runs automatically when the object goes out of scope or is deleted, and releases resources such as memory, files or locks.
They are almost identical: both can have data, functions, constructors, inheritance and access specifiers.
The only difference is the default: struct members and base classes are public by default, while class members and base classes are private by default.
By convention, struct is used for simple data aggregates and class for types with invariants and behaviour.
public members are accessible from anywhere, protected members from the class and its derived classes, and private members only within the class. A friend function or friend class declared inside a class can access its private members, which is used sparingly, for example to implement operator<< for printing an object.
Function overloading allows several functions with the same name but different parameter types or numbers, and the compiler picks the best match at compile time.
Default arguments give parameters default values, such as void connect(std::string host, int port = 443), so callers can omit them.
Defaults must be at the end of the parameter list.
Operator overloading lets user-defined types work with operators, such as adding two Vector objects with + or comparing them with ==.
It is defined as a member or non-member function named operator+.
Overloads should behave as users expect; operators such as ::, ., .* and ?: cannot be overloaded, and C++20 can generate comparison operators with operator<=>.
new allocates memory and calls the constructor, returns a typed pointer and throws std::bad_alloc on failure; delete calls the destructor and frees memory (new[] must be paired with delete[]). malloc and free only allocate and release raw memory without constructors or destructors. In modern C++, smart pointers and containers should manage memory instead of manual new and delete.
Namespaces group names to avoid conflicts between libraries, such as std::vector and a project's own vector type. You refer to names with the scope operator (std::cout) or bring them in with using declarations. using namespace std; in header files is bad practice because it pollutes every file that includes the header.
inline suggests the compiler replace a function call with the function's body to avoid call overhead, but modern compilers decide inlining themselves.
Today the main meaning of inline is that a function or variable may be defined in a header included by several files without violating the one-definition rule.
Functions defined inside a class body are implicitly inline.
Const correctness means marking everything that should not change as const: const variables, const references for parameters that are not modified (const std::string&), and const member functions, which promise not to change the object and can be called on const objects. It documents intent, prevents accidental changes and enables compiler optimisations.
Applied problems, trade-offs and questions about your own projects.
A virtual function in a base class can be overridden in derived classes, and calls through a base pointer or reference run the derived version based on the actual object type.
This is implemented with a vtable, a table of function pointers for each class, and a vptr in each object.
A base class with virtual functions should have a virtual destructor so derived objects are destroyed correctly.
Resource Acquisition Is Initialisation means tying a resource's lifetime to an object: the constructor acquires the resource and the destructor releases it.
Because destructors run automatically when objects go out of scope, even when exceptions are thrown, resources are never leaked.
Smart pointers, std::lock_guard and file streams all use RAII.
Smart pointers manage dynamically allocated memory automatically. std::unique_ptr has sole ownership and frees the object when it goes out of scope; it can be moved but not copied. std::shared_ptr shares ownership with reference counting, freeing the object when the last owner is gone. std::weak_ptr observes a shared_ptr without owning it, breaking reference cycles. make_unique and make_shared create them safely.
vector is the default dynamic array with fast random access. deque allows fast insertion at both ends. list is a doubly linked list for frequent insertions in the middle. map and set are sorted red-black trees with O(log n) operations, while unordered_map and unordered_set are hash tables with average O(1). stack, queue and priority_queue are adapters on top of these.
If B and C both inherit from A, and D inherits from both B and C, D normally contains two copies of A, making access to A's members ambiguous. Declaring B and C with virtual public A makes them share a single A subobject in D. The most derived class is then responsible for constructing A.
A pure virtual function is declared with = 0, such as virtual double area() const = 0;, and has no implementation in the base class.
A class with at least one pure virtual function is abstract and cannot be instantiated; derived classes must override the function to become concrete.
Abstract classes act as interfaces in C++.
The default copy constructor copies members one by one, so for a class holding a raw pointer, both objects end up pointing to the same memory (a shallow copy), and destroying one leaves the other with a dangling pointer and causes double deletion.
A deep copy allocates new memory and copies the data.
Using std::vector, std::string or smart pointers avoids writing this by hand.
static_cast performs checked conversions known at compile time, such as numeric conversions and up-casts. dynamic_cast safely down-casts in polymorphic class hierarchies, returning nullptr (or throwing for references) if the object is not of the target type. const_cast adds or removes const. reinterpret_cast reinterprets bits as another type and is dangerous. C-style casts should be avoided because they hide which conversion happens.
Code that may fail throws an exception object, usually derived from std::exception, which is caught by a matching catch block, ideally by const reference. During stack unwinding, destructors of local objects run, which is why RAII keeps resources safe. noexcept marks functions that do not throw, which helps optimisation; destructors should never throw.
Iterators are generalised pointers that let algorithms work on any container.
Algorithms in <algorithm> such as sort, find, find_if, count_if, transform, accumulate, binary_search and lower_bound take iterator ranges, and C++20 ranges versions take containers directly, as in std::ranges::sort(v).
Using algorithms is usually clearer and less buggy than writing loops.
A lambda is an anonymous function object: [capture](parameters) { body }.
Captures decide which outer variables it can use: [x] by value, [&x] by reference, [=] all used variables by value, [&] all by reference, and [this] the current object.
Capturing by reference is dangerous if the lambda outlives the variables, for example when stored or run on another thread.
System design, deep internals, leadership and tough follow-ups.
Move semantics, from C++11, let resources be transferred from temporary objects instead of copied.
An rvalue reference (T&&) binds to temporaries, and a move constructor or move assignment operator takes over the source's resources, such as a heap buffer, and leaves it empty. std::move casts an object to an rvalue to allow moving.
This makes returning and storing large objects much cheaper.
The rule of three says that if a class needs a custom destructor, copy constructor or copy assignment operator, it probably needs all three, because it manages a resource.
The rule of five adds the move constructor and move assignment operator.
The rule of zero says the best design avoids all of them by using RAII members, such as smart pointers and standard containers, which handle copying and cleanup automatically.
Templates let you write generic functions and classes that work with any type, resolved at compile time, as the STL does with std::vector<T>. Modern C++ features I use include auto, range-based for loops, lambdas, smart pointers, constexpr, structured bindings, std::optional and std::variant (C++17), and concepts, ranges and std::span (C++20), which make code safer and more expressive.
Object slicing happens when a derived object is copied into a base class object by value: only the base part is copied and the derived part is lost, so virtual functions behave like the base version.
For example, passing a Dog to a function taking an Animal by value.
Avoid it by passing polymorphic objects by reference or pointer.
std::thread (or std::jthread in C++20, which joins automatically and supports stop tokens) starts threads. std::mutex with std::lock_guard or std::scoped_lock protects shared data, std::condition_variable lets threads wait for conditions, std::atomic provides lock-free operations on simple values, and std::async and std::future run tasks and collect results. Data races are undefined behaviour.
Compile with warnings (-Wall -Wextra) and treat them as errors, run tests with sanitisers (AddressSanitizer for out-of-bounds and use-after-free, UndefinedBehaviorSanitizer, ThreadSanitizer for data races, MemorySanitizer for uninitialised reads), use Valgrind, run static analysers such as clang-tidy, and prefer safe abstractions such as containers, smart pointers, std::span and bounds-checked access.
The Curiously Recurring Template Pattern is when a class derives from a template instantiated with itself: class Derived : public Base<Derived>.
The base class can call derived methods through static_cast<Derived*>(this) at compile time, giving polymorphism without virtual function overhead (static polymorphism).
It is used for mixins, counters and performance-critical libraries.
Measure first with a profiler. Keep data contiguous (std::vector instead of std::list or maps of pointers), access memory sequentially, use structures of arrays for hot loops, avoid unnecessary copies with references and move semantics, reserve capacity for vectors, reduce heap allocations, avoid virtual calls in tight loops, and let the compiler optimise with -O2 or -O3 and link-time optimisation.
See all Software Engineer interview questions, covering Data Structures, Algorithms, OOP, System Design, Operating Systems and more.