C++ interview questions

C++ is a general-purpose programming language built on top of C, but it adds object-oriented programming, function overloading, templates, exceptions, and the Standard Template Library. In interviews, a simple way to answer is that C is mainly procedural, while C++ supports both procedural and object-oriented styles.

C++ also gives better support for abstraction and reusable design through classes and templates. A strong interview summary is: C is closer to low-level procedural programming, while C++ is designed to build larger and more structured applications.

A class is a blueprint that defines data members and member functions, while an object is a real instance created from that class. The class describes what the object will have, and the object is what actually occupies memory at runtime.

For interviews, keep it simple: class is the design, object is the created thing. If needed, mention that multiple objects can be made from the same class, and each object has its own copy of non-static data members.

A reference is another name for an existing variable. Once a reference is bound to an object, it cannot be changed to refer to a different object, which makes it different from a pointer.

References are commonly used for function parameters and return values because they avoid unnecessary copying and still let code work with the original object. In interviews, mention that a reference must be initialized when it is declared.

A pointer stores an address and can be reassigned, can be null, and needs dereferencing to access the pointed value. A reference is an alias to an existing variable, cannot be null in normal use, and works more like the original variable itself.

In interviews, compare them using three words: nullability, reassignment, and syntax. Use references when you want safer aliasing, and use pointers when you need optional ownership, dynamic memory handling, or explicit address manipulation.

Function overloading means defining multiple functions with the same name but different parameter lists. The compiler chooses the correct function based on the number or types of arguments passed.

This is compile-time polymorphism because the decision is made during compilation, not at runtime. A strong interview point is that changing only the return type does not create a valid overload.

Operator overloading allows programmers to define how operators such as `+`, `==`, or `<<` should work for user-defined types. It makes custom classes feel more natural to use when the operator meaning is clear.

The main interview point is that operator overloading should improve readability, not create confusing behavior. It does not let you invent new operators, and it does not change the meaning of operators for built-in types.

A constructor is a special member function that runs automatically when an object is created. Its main job is to initialize the object so it starts in a valid and useful state.

In interviews, mention that a constructor has the same name as the class and has no return type. Constructors can be default, parameterized, or copied, depending on how the object needs to be initialized.

The most common constructors are the default constructor, parameterized constructor, and copy constructor. The default constructor creates an object without arguments, the parameterized constructor initializes it with values, and the copy constructor creates a new object from an existing one.

A short interview answer is to name these three first, because they are asked most often. In modern C++, you can also mention move constructors when the interviewer goes one step deeper.

A destructor is a special member function that runs automatically when an object is destroyed. Its main purpose is to release resources such as dynamic memory, file handles, or locks owned by the object.

In interviews, say that a destructor has the same name as the class with a `~` before it and it does not take parameters. A good destructor helps prevent resource leaks by cleaning up at the end of the object lifetime.

`new` and `delete` are C++ operators, while `malloc()` and `free()` come from C. The biggest practical difference is that `new` calls constructors and `delete` calls destructors, but `malloc()` and `free()` only allocate and release raw memory.

For interviews, add that `new` returns the correct pointer type and is type-aware, while `malloc()` returns `void*` and needs casting in C++. In C++ code, `new` and `delete` are generally preferred, but modern code often prefers smart pointers over manual memory management.

Stack memory is used for local variables and function call frames, and it is managed automatically. Heap memory is used for dynamic allocation, and the programmer controls its lifetime directly or through smart pointers.

A strong interview summary is: stack is fast and automatic, heap is flexible but needs careful management. Objects on the heap can outlive the function that created them, which is useful but also creates risk of leaks if cleanup is missed.

A copy constructor creates a new object as a copy of an existing object of the same class. It is usually written as a constructor that takes a const reference to another object of that class.

This is especially important when a class owns resources like dynamic memory. In interviews, mention that the default copy constructor performs member-wise copying, which may not be enough for classes that manage raw pointers.

A shallow copy copies member values as they are, so if a class stores a pointer, both objects may end up pointing to the same memory. A deep copy creates a separate copy of the actual resource, so each object owns its own independent data.

This question matters when classes manage dynamic memory or other external resources. In interviews, say that shallow copy is risky for ownership-based classes because changes or deletion through one object can break the other object.

The copy assignment operator copies data from one existing object to another existing object using the `=` operator. It is different from the copy constructor because the target object has already been created before assignment happens.

In interviews, explain it using timing: copy constructor runs during object creation, while copy assignment runs after creation. If the class manages resources, the assignment operator must handle self-assignment and old resource cleanup carefully.

The `this` pointer is an implicit pointer available inside non-static member functions, and it points to the current object. It lets a member function refer to the exact object that called it.

A common interview use case is disambiguating member variables from parameters with the same name, or returning `*this` for method chaining. The main point is that `this` exists only for object-specific member functions, not static ones.

A static data member belongs to the class itself, so it is shared by all objects of that class. A static member function also belongs to the class and can be called without creating an object.

In interviews, the key difference is that static functions can access only static members directly because they do not have a `this` pointer. Static members are useful for shared counters, configuration values, or class-level utilities.

A friend function is a function that is not a member of a class but is allowed to access that class's private and protected members. It is declared inside the class using the `friend` keyword.

The important interview point is that friendship gives special access, but it should be used carefully because it weakens encapsulation. It is often used when an external function needs tight access, such as some operator overloading cases.

An inline function is a function for which the compiler is requested to replace the function call with the actual function body when appropriate. This can reduce call overhead for very small functions.

In interviews, mention that `inline` is only a request, not a guarantee, because the compiler decides what is best. It is mainly useful for short and frequently used functions, but very large inline functions can hurt readability and code size.

A namespace is used to group related code and avoid name conflicts between identifiers that may have the same name. It helps organize larger programs and libraries more cleanly.

The most common example is `std`, which contains standard library names like `std::cout` and `std::vector`. In interviews, say that namespaces improve clarity and prevent collisions when different libraries define similar names.

In C++, `struct` and `class` are almost the same in terms of features, but their default access levels are different. Members of a `struct` are public by default, while members of a `class` are private by default.

A common interview rule of thumb is to use `struct` for simple data-like types and `class` for behavior-rich designs, though this is a style choice, not a strict language rule. The important part is knowing the default access difference.

Inheritance is a feature that allows one class to acquire the properties and behavior of another class. The existing class is called the base class, and the new class is called the derived class.

It supports code reuse and helps model real relationships such as 'Car is a Vehicle'. In interviews, mention that inheritance is useful when the derived class truly represents a more specific version of the base class.

The main inheritance forms discussed in interviews are single, multiple, multilevel, hierarchical, and hybrid inheritance. They describe different ways derived classes can be connected to base classes.

The most important practical point is that C++ supports multiple inheritance, which makes it powerful but can also create complexity like ambiguity. If the interviewer asks further, you can mention the diamond problem and virtual inheritance.

Polymorphism means the same interface or function name can behave differently in different situations. In C++, it mainly appears as compile-time polymorphism through overloading and runtime polymorphism through virtual functions.

A short interview answer is that polymorphism improves flexibility and lets the same call work with different object types. The key is to separate compile-time decisions from runtime decisions when explaining it.

Compile-time polymorphism is resolved by the compiler, so the function to call is decided before the program runs. Runtime polymorphism is resolved while the program is running, usually through virtual functions and base-class pointers or references.

Common compile-time examples are function overloading and operator overloading. Common runtime examples are method overriding with virtual functions, where the actual object type decides which function runs.

A virtual function is a base-class member function declared with the `virtual` keyword so that a derived class can override it for runtime polymorphism. When the function is called through a base pointer or base reference, C++ chooses the derived version if it exists.

This is one of the most asked C++ interview questions because it checks whether you understand dynamic binding. A strong answer is that virtual functions let code work through a base interface while still using derived behavior correctly.

A base class destructor should be virtual when objects of derived classes may be deleted through a base-class pointer. This ensures that the derived destructor runs first and cleanup happens correctly for the whole object.

Without a virtual destructor, deleting through a base pointer can cause incomplete destruction and resource leaks. In interviews, say this is essential for polymorphic base classes because it protects correct object cleanup.

A pure virtual function is a virtual function declared with `= 0`, which means the base class is defining an interface that derived classes are expected to implement. It makes the base class incomplete in behavior for that function.

In interviews, the clean explanation is that pure virtual functions are used to create abstract interfaces. A class with at least one pure virtual function usually cannot be instantiated directly.

An abstract class is a class that has at least one pure virtual function and therefore cannot be instantiated directly. It is mainly used as a base type to define common behavior and a required interface.

This is useful when you want derived classes to share a contract but provide their own concrete implementation. In interviews, connect abstract classes with interface-style design and runtime polymorphism.

Object slicing happens when a derived object is assigned or passed by value as a base object, causing the derived-specific part to be cut off. The base object keeps only the base-class portion of the original object.

This is why polymorphic objects are usually passed by reference or pointer, not by value. In interviews, a strong one-line summary is: passing derived objects by value into base objects loses the derived state and behavior.

Overloading means using the same function name with different parameter lists, usually in the same scope, and it is resolved at compile time. Overriding means a derived class provides a new version of a base class virtual function, and it is resolved at runtime.

In interviews, compare them using three things: where they happen, what must match, and when the decision is made. Overloading changes parameters, while overriding keeps the interface aligned and changes the implementation in a derived class.

Templates let you write generic code that works with different data types without rewriting the same logic again and again. The compiler creates the required version when the template is used with a specific type.

Templates are one of the strongest features of C++ because they support reusable and type-safe generic programming. In interviews, a short example is that a single `maxValue` template can work for `int`, `double`, or other comparable types.

A function template creates generic functions, while a class template creates generic classes. Both use type parameters, but one is meant for behavior and the other for designing reusable data structures or objects.

In interviews, keep it simple: function templates generalize functions, class templates generalize classes. Standard examples are a generic `swap()` function and a generic container like `std::vector<T>`.

The STL is a standard library that provides ready-made containers, iterators, algorithms, and function objects. It saves developers from writing common data structures and algorithms from scratch.

A good interview summary is that STL gives reusable building blocks such as `vector`, `map`, `sort`, and iterators. Knowing how containers and algorithms work together is often more important than memorizing every STL type.

`vector` stores elements in contiguous memory, which gives fast random access and good cache performance. `list` is a doubly linked list, so inserting or deleting in the middle is easier, but random access is slow.

In interviews, choose based on use case rather than theory. Use `vector` by default for most cases, and choose `list` only when frequent middle insertions or deletions matter more than direct indexing and cache-friendly access.

`map` stores keys in sorted order and is usually implemented using a balanced tree, while `unordered_map` stores keys using hashing and does not keep them sorted. Because of that, lookup behavior and ordering are different.

A short interview answer is: use `map` when order matters, and use `unordered_map` when fast average lookup matters more than ordering. Also mention that `unordered_map` can degrade in poor hash situations, while `map` gives ordered traversal.

Iterators are objects that let you move through elements of a container one by one. They act like generalized pointers and provide a common way for STL algorithms to work with different containers.

In interviews, say that iterators connect containers and algorithms. For example, `sort`, `find`, and `copy` use iterators instead of being written separately for every container type.

A lambda is an anonymous function that can be defined directly where it is needed. It is useful for short logic passed to algorithms, callbacks, or local custom behavior.

The main interview point is that lambdas make code shorter and clearer when the function is small and used only once. You can also mention captures, which let the lambda use variables from the surrounding scope.

The `auto` keyword tells the compiler to deduce the variable type from its initializer. It is useful when the type is obvious from the right side or when the real type is long and difficult to write.

In interviews, mention that `auto` improves readability when used carefully, especially with iterators and template-heavy code. It should not be used in a way that hides important meaning or makes the code harder to understand.

Smart pointers are objects that manage dynamically allocated memory automatically, so manual `delete` is usually not needed. They help reduce memory leaks and make ownership clearer in modern C++ code.

The key interview point is that smart pointers follow RAII, which ties resource cleanup to object lifetime. In modern C++, raw `new` and `delete` are used much less often because smart pointers are safer and easier to maintain.

`unique_ptr` represents exclusive ownership, so only one smart pointer owns the object at a time. `shared_ptr` allows shared ownership using reference counting, and `weak_ptr` observes a `shared_ptr`-managed object without increasing its ownership count.

In interviews, say that `unique_ptr` is usually the first choice because ownership is simple and efficient. `shared_ptr` is useful only when ownership really is shared, and `weak_ptr` is important for breaking cycles that could otherwise prevent cleanup.

RAII stands for Resource Acquisition Is Initialization. It means a resource such as memory, a file, or a lock is tied to the lifetime of an object, so cleanup happens automatically in the destructor.

This is a very important C++ design idea because it makes code safer during both normal execution and exceptions. In interviews, a simple summary is: acquire resources in constructors and release them in destructors.

The Rule of Three says that if a class needs a custom destructor, copy constructor, or copy assignment operator, it often needs all three. The Rule of Five extends this idea in modern C++ by also including the move constructor and move assignment operator.

The Rule of Zero is the cleaner modern goal: design classes so they do not need manual special member functions at all, usually by relying on standard library types and smart pointers. In interviews, this shows you understand both classic memory management and modern C++ style.

An lvalue represents an object that has a stable location in memory and can usually appear on the left side of an assignment. An rvalue is usually a temporary value or expression result that does not have the same lasting identity.

Interviewers ask this because it connects directly to move semantics and rvalue references. A simple memory trick is: lvalues usually have names, while rvalues are often temporary results like `a + b` or a returned temporary object.

Move semantics lets a program transfer ownership of resources from one object to another instead of making an expensive deep copy. It improves performance for temporary objects and resource-owning classes.

In interviews, connect move semantics to rvalue references and modern containers like `vector`, which can move elements when possible. A strong one-line answer is: moving transfers resources, copying duplicates them.

The `const` keyword means a value should not be modified through that name or interface. It can be used with variables, pointers, references, function parameters, return types, and member functions.

In interviews, the most useful angle is intent and safety: `const` helps prevent accidental modification and makes interfaces clearer. A `const` member function promises not to modify the visible state of the object.

In modern C++, `nullptr` is the correct null pointer literal because it has its own type and avoids ambiguity. `NULL` is usually an older macro, and `0` can also represent a null pointer in older code, but both are less clear and can cause overload confusion.

The best interview answer is that `nullptr` was introduced to make pointer code safer and more expressive. In new C++ code, prefer `nullptr` because the intent is clear and the type system handles it better.

C++ handles exceptions using `try`, `throw`, and `catch`. Code that may fail is placed inside a `try` block, an error is signaled with `throw`, and matching handlers process the exception in `catch` blocks.

In interviews, mention that exceptions separate error handling from normal flow, but resource safety still matters, which is why RAII is important. Also say that destructors of local objects are called during stack unwinding, which helps automatic cleanup.

`static_cast` is used for well-defined compile-time conversions such as numeric conversions or related class pointer conversions when you know the relationship. `dynamic_cast` is used mainly in polymorphic class hierarchies for safe runtime checked downcasting, while `reinterpret_cast` performs very low-level reinterpretation and should be used very carefully.

The interview-safe rule is: prefer the safest cast that matches the need. Use `reinterpret_cast` rarely because it is the easiest to misuse and can make code hard to reason about.

`size()` tells how many elements are currently stored in the vector, while `capacity()` tells how much storage has been allocated before the vector needs to grow again. Capacity is usually greater than or equal to size.

This matters in interviews because people often confuse logical element count with allocated storage. A vector can have size 5 and capacity 8, which means it stores 5 valid elements and has room for a few more without immediate reallocation.

Compile-time errors are found by the compiler before the program runs, such as syntax errors or type mismatches. Runtime errors happen while the program is executing, such as division by zero, invalid memory access, or failed logic assumptions.

In interviews, the best summary is that compile-time errors stop the build, while runtime errors appear only when the program actually runs. Good testing, safer abstractions, and modern C++ features help reduce runtime failures.