Cpp Programming Practice Exam

Question 1 Cpp Programming

What is the vptr (virtual table pointer)?

Each object of a class with virtual functions contains a hidden vptr set by the constructor, pointing to that class's vtable. The vptr is what enables runtime polymorphism through base pointers/references. A vtable is a per-class table of pointers to virtual functions. Each object with virtuals carries a hidden vptr pointing to its class's vtable, enabling dynamic dispatch via the correct override at runtime. std::bind (in <functional>) creates a new callable by binding arguments to a function:

auto f = std::bind(add, 5, std::placeholders::_1);
f(3); // 8

Largely superseded by lambdas. You can initialize a variable in the condition of if or switch:
if (auto it = m.find(k); it != m.end()) { use(it->second); }
The variable lives until the end of the if/switch block.

Question 2 Cpp Programming

What is a class template?

A translation unit is a source file plus the result of including all its headers, after preprocessing. Header files typically contain declarations and inline definitions, included via #include in many translation units. A class template defines a blueprint for a class parameterized by types:
template<typename T> class Stack { std::vector<T> data; public: void push(T val); T pop(); };
Used as Stack<int> s;. Operator overloading lets you redefine how operators work for user-defined types:
MyClass operator+(const MyClass& rhs) const { return MyClass(value + rhs.value); }
Most operators can be overloaded except ::, ., .*, and ?:. A race condition occurs when the outcome of a program depends on the non-deterministic timing of concurrent accesses to shared data, producing different results on each run. Protect shared data with synchronization (mutex, atomics).

Question 3 Cpp Programming

What is constexpr in C++?

std::launder(p) obtains a pointer to an object occupying memory whose lifetime was revived by placement new. It blocks the compiler from assuming the pointer still refers to the old object. A parameterized constructor accepts arguments used to initialize member variables:
class Point { int x,y; public: Point(int a, int b): x(a), y(b) {} }; A delegating constructor calls another constructor of the same class in its initializer list:

Box(int s) : Box(s,s,s) {}
Box(int l,int w,int h) : ... {}

Prevents code duplication. constexpr declares that a variable or function can be evaluated at compile time:

constexpr int square(int x) { return x*x; }
constexpr int s = square(5);

In C++14+ it may contain loops and conditionals; C++20 added consteval (must be compile-time).

Question 4 Cpp Programming

What is a delegating constructor?

A delegating constructor calls another constructor of the same class in its initializer list:

Box(int s) : Box(s,s,s) {}
Box(int l,int w,int h) : ... {}

Prevents code duplication. Operator overloading lets you redefine how operators work for user-defined types:
MyClass operator+(const MyClass& rhs) const { return MyClass(value + rhs.value); }
Most operators can be overloaded except ::, ., .*, and ?:. A smart pointer is a class that manages a dynamically allocated object and automatically deletes it when no longer needed, following RAII. The main types are std::unique_ptr, std::shared_ptr, and std::weak_ptr. A mutable member can be modified even inside const member functions:
mutable int cache_;
Useful for lazy initialization, caches, and mutexes.

Question 5 Cpp Programming

What is a deadlock?

A class template defines a blueprint for a class parameterized by types:
template<typename T> class Stack { std::vector<T> data; public: void push(T val); T pop(); };
Used as Stack<int> s;. constexpr declares that a variable or function can be evaluated at compile time:

constexpr int square(int x) { return x*x; }
constexpr int s = square(5);

In C++14+ it may contain loops and conditionals; C++20 added consteval (must be compile-time). std::lock_guard is a lightweight RAII lock with no extra features.
std::unique_lock additionally supports deferred locking, manual unlock, and ownership transfer (movable). Use unique_lock when you need that flexibility. A deadlock occurs when two or more threads each hold a lock and wait for a lock held by another, so none can proceed. Prevent deadlocks by acquiring locks in a fixed order or using std::scoped_lock (C++17) with deadlock-avoidance algorithms.

Question 6 Cpp Programming

What are coroutines (C++20)?

std::move is a cast that converts an lvalue into an rvalue reference, signaling that the object's resources may be moved from:
std::string b = std::move(a);
After the move, a is in a valid but unspecified state. Fold expressions reduce a parameter pack over a binary operator:
template<typename... Args> auto sum(Args... args) { return (... + args); }
Supported operators include +, *, &&, ||, and the comma operator. C++20 coroutines are functions that can be suspended and resumed using co_await, co_yield, and co_return. They are used to build generators, async I/O, and lazy computations without callback chains. std::array has a fixed size known at compile time and is stored on the stack:
std::array<int, 5> a = {1,2,3,4,5};
std::vector is dynamically sized and uses heap memory. Use array when the size is constant for better performance.

Question 7 Cpp Programming

What are the capture modes in a C++ lambda?

A delegating constructor calls another constructor of the same class in its initializer list:

Box(int s) : Box(s,s,s) {}
Box(int l,int w,int h) : ... {}

Prevents code duplication. std::array has a fixed size known at compile time and is stored on the stack:
std::array<int, 5> a = {1,2,3,4,5};
std::vector is dynamically sized and uses heap memory. Use array when the size is constant for better performance. std::deque (double-ended queue) supports O(1) insertion and removal at both ends:
std::deque<int> d; d.push_front(1); d.push_back(2);
Unlike vector, it does not store elements in a single contiguous block. Lambda capture options:

[x] – capture x by value
[&x] – capture x by reference
[=] – capture all used variables by value
[&] – capture all by reference
[=, &x] – all by value except x by reference

Question 8 Cpp Programming

What is a forwarding reference (universal reference)?

Default member initializers specify a default value for a member at its declaration:
int count = 0;
They apply when the member is not mentioned in the constructor's initializer list. A forwarding reference is T&& in a deduced context (e.g., a function template parameter). It binds to both lvalues (becoming T&) and rvalues (becoming T), unlike a plain rvalue reference. A function pointer stores the address of a function:
int (*fp)(int,int) = &add;
Can be invoked as fp(2,3). Useful for callbacks and C-style APIs. In C++ prefer std::function or lambdas. Exception safety describes guarantees a function offers if an exception occurs:

Nothrow – never throws
Strong – either succeeds or has no effect
Basic – no leaks, object still usable
No – anything can happen

Question 9 Cpp Programming

What is const correctness in C++?

A class is a user-defined type that encapsulates data members and member functions. Defined with the class keyword:
class MyClass { public: int x; void show(); }; Const correctness means using const wherever data should not be modified:

const int x = 5; – immutable variable
void foo(const std::string& s) – parameter not modified
int getVal() const; – method doesn't modify the object

It prevents bugs and enables compiler optimizations. Name hiding occurs when a derived class declares a name that matches one in the base: the base name is hidden in the derived class even if signatures differ. A using Base::name; declaration can unhide overloaded base functions. std::promise lets a producer set a value or exception; the matching std::future lets a consumer retrieve it:

std::promise<int> p; auto f = p.get_future();
p.set_value(42); int v = f.get();

Question 10 Cpp Programming

What is undefined behavior (UB)?

dynamic_cast safely converts pointers/references within an inheritance hierarchy with runtime type checking (RTTI). It returns nullptr (or throws std::bad_cast for references) if the cast is invalid:
Derived* d = dynamic_cast<Derived*>(basePtr); std::thread (in <thread>) launches a new OS thread running a callable:
std::thread t([]{ /* work */ }); t.join();
You must call either join() or detach() on every std::thread before destruction. <=> (the spaceship operator) returns a comparison category type indicating ordering:
auto cmp = a <=> b; if (cmp < 0) ...
With = default the compiler generates all six relational operators. Undefined behavior is anything the standard does not define: signed integer overflow, null-pointer dereference, reading uninitialized memory, out-of-bounds access, etc. The compiler may assume UB never happens and optimize accordingly.

Question 11 Cpp Programming

What are const pointers and pointers to const?

A delegating constructor calls another constructor of the same class in its initializer list:

Box(int s) : Box(s,s,s) {}
Box(int l,int w,int h) : ... {}

Prevents code duplication. A shallow copy duplicates pointers but not the pointed-to data, causing both objects to share the same memory.
A deep copy duplicates the actual data, giving each object its own independent copy. Deep copies are needed when a class manages raw dynamic memory. constexpr declares that a variable or function can be evaluated at compile time:

constexpr int square(int x) { return x*x; }
constexpr int s = square(5);

In C++14+ it may contain loops and conditionals; C++20 added consteval (must be compile-time).

int* const p – const pointer: cannot be reseated, pointee can change
const int* p – pointer to const: cannot modify pointee, pointer can be reseated
const int* const p – both const

Question 12 Cpp Programming

What is std::list in C++?

std::list is a doubly-linked list:

O(1) insertion and deletion anywhere (given an iterator)
No random access (no operator[])
Higher memory overhead per element due to pointers

A function pointer stores the address of a function:
int (*fp)(int,int) = &add;
Can be invoked as fp(2,3). Useful for callbacks and C-style APIs. In C++ prefer std::function or lambdas. std::atomic (in <atomic>) provides lock-free thread-safe access to a value:
std::atomic<int> counter{0}; counter.fetch_add(1);
Operations are visible to other threads in a defined order (memory order). Move semantics allow transferring resources from one object to another without copying. Enabled by rvalue references (&&) and implemented via a move constructor and move assignment operator. This greatly improves performance for temporary objects.

Question 13 Cpp Programming

What is the difference between std::lock_guard and std::unique_lock?

#define is a textual macro with no type or scope; it can cause subtle bugs.
const (or constexpr) is a typed, scoped constant that participates in the type system. Prefer const/constexpr for constants. Implementation-defined behavior must be documented by the implementation (compiler/library) but is not specified by the standard. Examples: sizeof(int), byte order, and the value of a char after overflow. std::lock_guard is a lightweight RAII lock with no extra features.
std::unique_lock additionally supports deferred locking, manual unlock, and ownership transfer (movable). Use unique_lock when you need that flexibility. Structured bindings unpack aggregates, pairs, tuples, and structured bindings:

auto [key, value] = *map.begin();
auto [x,y,z] = getPoint();

Replaces manual std::tie in many cases.

Question 14 Cpp Programming

What is operator overloading as a member vs. non-member?

A binary operator can be overloaded as a member (left operand is *this) or a non-member (often friend) taking both operands. The << stream operator is overloaded as a non-member so the left operand can be a stream. std::terminate is called when:

An exception escapes a noexcept function
An exception is thrown during stack unwinding
No catch is found

It calls the current std::terminate_handler, defaulting to std::abort. std::async runs a callable asynchronously and returns a std::future with the result:

auto fut = std::async(std::launch::async, []{ return 42; });
int v = fut.get();

override (C++11) asserts that a method overrides a base virtual; the compiler errors otherwise.
final prevents further overriding in derived classes (or prevents further derivation when applied to a class).

Question 15 Cpp Programming

What is std::any (C++17)?

std::exception is the base class for standard exceptions. Key derived classes:

std::runtime_error – runtime problems
std::logic_error – logical errors
std::bad_alloc – memory allocation failure
std::out_of_range – index out of bounds

A destructor (~ClassName()) runs when an object's lifetime ends. It performs cleanup like releasing resources. It is called automatically on stack objects when their scope exits, and on heap objects via delete. std::any is a type-safe container for a single value of any copy-constructible type:

std::any a = 42; a = std::string("hi");
auto s = std::any_cast<std::string>(a);

Include guards (or #pragma once) prevent a header from being processed more than once per translation unit:

#ifndef FOO_H
#define FOO_H
// ...
#endif

Avoids multiple-definition errors from repeated inclusion.

Question 16 Cpp Programming

What is a constructor in C++?

A smart pointer is a class that manages a dynamically allocated object and automatically deletes it when no longer needed, following RAII. The main types are std::unique_ptr, std::shared_ptr, and std::weak_ptr. A constructor is a special member function automatically invoked when an object is created. It has the same name as the class and no return type. If no constructor is provided, the compiler generates a default constructor. SFINAE (Substitution Failure Is Not An Error) means that when substituting template parameters fails, the compiler silently removes that overload rather than aborting. It's the basis of type traits and many compile-time checks. std::list is a doubly-linked list:

O(1) insertion and deletion anywhere (given an iterator)
No random access (no operator[])
Higher memory overhead per element due to pointers

Question 17 Cpp Programming

What is an inline function?

An inline function is a hint to the compiler to insert the function body at the call site to avoid call overhead. Modern compilers ignore the hint and decide automatically. Inline functions must be defined in every translation unit that uses them. A default constructor is one that can be called with no arguments. It is generated by the compiler only if no other constructor is declared. You can force its creation with = default:
MyClass() = default; A friend class can access the private and protected members of the class that declares it:
friend class Helper;
Useful for tightly coupled classes (e.g., iterators over a container). static_assert(cond, "message") performs a compile-time assertion. The program is ill-formed if the condition is false:
static_assert(sizeof(void*) == 8, "Requires 64-bit");
Useful for enforcing type traits and alignment requirements.

Question 18 Cpp Programming

What are iterators in C++?

A virtual function is declared with the virtual keyword in a base class, enabling runtime polymorphism:
virtual void speak() { }
Derived classes can override it, and the correct version is called via a base class pointer using the vtable. Iterators are objects that act like generalized pointers, providing a uniform way to traverse containers:
for (auto it = v.begin(); it != v.end(); ++it) { /* use *it */ }
Categories include: input, output, forward, bidirectional, and random access. SFINAE (Substitution Failure Is Not An Error) means that when substituting template parameters fails, the compiler silently removes that overload rather than aborting. It's the basis of type traits and many compile-time checks. Initialization happens in the member initializer list (or default member initializer) and uses member initialization.
Assignment happens in the constructor body, where the member is first default-constructed then overwritten. Prefer initialization for efficiency.

Question 19 Cpp Programming

What is the difference between a class and a struct in C++?

Stack unwinding is the process of destroying automatic objects in each stack frame as an exception propagates toward a catch block. It makes RAII cleanup reliable. If no handler is found, std::terminate is called. The only default difference is access control:

class members are private by default
struct members are public by default

Both can have methods, constructors, and inheritance. An assertion is a runtime check of an invariant. assert(expr) (in <cassert>) aborts the program with a message if expr is false. Define NDEBUG to disable assertions in release builds. std::unordered_map stores key-value pairs in a hash table:
std::unordered_map<std::string, int> m;
Provides average O(1) lookup, insertion, and deletion. Keys are not sorted. Requires a hash function for custom key types.

Question 20 Cpp Programming

What are access specifiers in C++?

std::filesystem (C++17) provides portable paths, files, and directories:
for (auto& e : std::filesystem::directory_iterator(".")) std::cout << e.path() << '\n'; Template specialization provides a custom implementation for a specific type:
template<> class Stack<bool> { /* optimized for bool */ };
There is full specialization (one specific type) and partial specialization (subset of parameters). C++ has three access levels:

public – accessible everywhere
protected – accessible to the class, friends, and derived classes
private – accessible only to the class and its friends

Default is private for class and public for struct. #define is a textual macro with no type or scope; it can cause subtle bugs.
const (or constexpr) is a typed, scoped constant that participates in the type system. Prefer const/constexpr for constants.

Question 21 Cpp Programming

What is std::mutex?

std::mutex provides mutual exclusion for protecting shared data:
std::lock_guard<std::mutex> lk(m); /* critical section */
Always use RAII lock guards (lock_guard, unique_lock, scoped_lock) to avoid forgetting unlock(). std::lock_guard is a lightweight RAII lock with no extra features.
std::unique_lock additionally supports deferred locking, manual unlock, and ownership transfer (movable). Use unique_lock when you need that flexibility. A std::condition_variable allows threads to wait until notified that a predicate is satisfied:
std::unique_lock<std::mutex> lk(m); cv.wait(lk, []{ return ready; });
Used to implement blocking queues and other synchronization patterns. An abstract class has at least one pure virtual function and cannot be instantiated.
A concrete class implements all inherited pure virtuals and can be instantiated.

Question 22 Cpp Programming

What is the difference between std::array and std::vector?

An abstract class contains at least one pure virtual function. It cannot be instantiated directly and serves as an interface or base for derived classes that provide implementations. A dangling reference refers to memory that is no longer valid, typically because the referenced object was destroyed. Never return a reference to a local variable:
int& bad() { int x; return x; } // undefined behavior std::array has a fixed size known at compile time and is stored on the stack:
std::array<int, 5> a = {1,2,3,4,5};
std::vector is dynamically sized and uses heap memory. Use array when the size is constant for better performance. A smart pointer is a class that manages a dynamically allocated object and automatically deletes it when no longer needed, following RAII. The main types are std::unique_ptr, std::shared_ptr, and std::weak_ptr.

Question 23 Cpp Programming

What is the difference between delete and delete[]?

delete deallocates memory for a single object and calls one destructor.
delete[] deallocates a C-style array allocated with new T[n] and calls the destructor for each element. Mismatching them is undefined behavior. The One Definition Rule states that any program must have exactly one definition of each non-inline function or variable across all translation units. Inline functions and class definitions may appear in multiple translation units identically.

int* const p – const pointer: cannot be reseated, pointee can change
const int* p – pointer to const: cannot modify pointee, pointer can be reseated
const int* const p – both const

Compile-time (static) polymorphism uses function/operator overloading and templates; the resolved call is determined at compile time.
Runtime (dynamic) polymorphism uses virtual functions and inheritance; the call is dispatched via the vtable at runtime.

Question 24 Cpp Programming

What is inheritance in C++?

A conversion constructor is a non-explicit single-argument constructor that allows implicit conversion from that argument type to the class type. Marking it explicit blocks the implicit conversion. A static member function belongs to the class, not an instance. It has no this pointer and can only access static members:
static int getCount();
Called as MyClass::getCount(). A friend function is a non-member function granted access to a class's private and protected members:
friend void print(const MyClass&);
Declared inside the class but defined outside. Breaks encapsulation, so use sparingly. Inheritance allows a derived class to inherit members from a base class:
class Dog : public Animal { };
This promotes code reuse and establishes an is-a relationship.

Question 25 Cpp Programming

What is a destructor and when is it called?

Perfect forwarding uses std::forward<T> with forwarding references (T&& in a template) to preserve the value category (lvalue/rvalue) of the original argument when passing to another function. It avoids unnecessary copies. A destructor (~ClassName()) runs when an object's lifetime ends. It performs cleanup like releasing resources. It is called automatically on stack objects when their scope exits, and on heap objects via delete. A deadlock occurs when two or more threads each hold a lock and wait for a lock held by another, so none can proceed. Prevent deadlocks by acquiring locks in a fixed order or using std::scoped_lock (C++17) with deadlock-avoidance algorithms. A variadic template accepts any number of template arguments:
template<typename... Args> void f(Args... args);
Expanded using parameter packs, often via recursion or fold expressions.

Question 26 Cpp Programming

What are std::enable_if and std::void_t?

std::system_clock – wall-clock time (since epoch)
std::steady_clock – monotonic, never goes backward; ideal for intervals
std::high_resolution_clock – smallest tick period available

reinterpret_cast performs low-level, implementation-defined bitwise conversions between pointer/integer types:
auto p = reinterpret_cast<void*>(0x1234);
Use only when you fully understand the platform's memory layout. std::enable_if<Cond, T> yields T when Cond is true, and is otherwise ill-formed (SFINAE):
template<typename T> typename std::enable_if<std::is_integral<T>::value, T>::type f(T);
std::void_t<...> detects valid expressions in trait detectors. A function pointer stores the address of a function:
int (*fp)(int,int) = &add;
Can be invoked as fp(2,3). Useful for callbacks and C-style APIs. In C++ prefer std::function or lambdas.

Question 27 Cpp Programming

What is virtual inheritance?

noexcept declares that a function will not throw exceptions:
void process() noexcept { }
If a noexcept function does throw, std::terminate is called. It helps the compiler optimize code and is important for move operations. Virtual inheritance declares a base class as virtual in the derived class's base list:
class D : virtual public B {};
It guarantees that only one instance of B exists in the inheritance graph, solving the diamond problem. The <algorithm> header provides generic functions that work with iterators:

std::sort(v.begin(), v.end())
std::find(v.begin(), v.end(), val)
std::count_if(v.begin(), v.end(), pred)
std::transform, std::accumulate, std::for_each

override (C++11) asserts that a method overrides a base virtual; the compiler errors otherwise.
final prevents further overriding in derived classes (or prevents further derivation when applied to a class).

Question 28 Cpp Programming

What is a variadic template?

Modules replace header files with faster, more isolated translation units:

export module math;
export int add(int a,int b){return a+b;}

Consumers use import math;. Avoids macro leakage and macro-order issues. An assertion is a runtime check of an invariant. assert(expr) (in <cassert>) aborts the program with a message if expr is false. Define NDEBUG to disable assertions in release builds. std::lock_guard is a lightweight RAII lock with no extra features.
std::unique_lock additionally supports deferred locking, manual unlock, and ownership transfer (movable). Use unique_lock when you need that flexibility. A variadic template accepts any number of template arguments:
template<typename... Args> void f(Args... args);
Expanded using parameter packs, often via recursion or fold expressions.

Question 29 Cpp Programming

What is exception handling in C++?

A virtual function is declared with the virtual keyword in a base class, enabling runtime polymorphism:
virtual void speak() { }
Derived classes can override it, and the correct version is called via a base class pointer using the vtable. Template metaprogramming uses templates to perform computation at compile time. Examples include std::tuple, std::integral_constant, and SFINAE. It produces highly optimized code but can be hard to read. Include guards (or #pragma once) prevent a header from being processed more than once per translation unit:

#ifndef FOO_H
#define FOO_H
// ...
#endif

Avoids multiple-definition errors from repeated inclusion. C++ uses try-catch blocks for exception handling:
try { throw std::runtime_error("fail"); } catch (const std::exception& e) { std::cout << e.what(); }
Exceptions propagate up the call stack until a matching catch block is found.

Question 30 Cpp Programming

What is the difference between deep copy and shallow copy?

A reverse iterator traverses a container from end to beginning:
for (auto rit = v.rbegin(); rit != v.rend(); ++rit) { std::cout << *rit; }
Obtained via rbegin() and rend() member functions. A shallow copy duplicates pointers but not the pointed-to data, causing both objects to share the same memory.
A deep copy duplicates the actual data, giving each object its own independent copy. Deep copies are needed when a class manages raw dynamic memory. Compile-time (static) polymorphism uses function/operator overloading and templates; the resolved call is determined at compile time.
Runtime (dynamic) polymorphism uses virtual functions and inheritance; the call is dispatched via the vtable at runtime. std::unique_ptr provides exclusive ownership of a dynamically allocated object:
auto p = std::make_unique<int>(42);
It cannot be copied, only moved. The object is deleted when the unique_ptr goes out of scope.

Question 31 Cpp Programming

What is a memory leak?

Brace initialization uses {} to initialize any object and prevents narrowing conversions:

int x{5}; // OK
int y{3.14}; // ERROR: narrowing

It is the recommended initialization syntax in modern C++. A memory leak occurs when dynamically allocated memory is never freed, gradually exhausting available memory. Prevent leaks by preferring RAII: smart pointers, containers, and other resource-managing classes instead of raw new/delete. std::move is a cast that converts an lvalue into an rvalue reference, signaling that the object's resources may be moved from:
std::string b = std::move(a);
After the move, a is in a valid but unspecified state. std::vector is a dynamic array that grows automatically:
std::vector<int> v = {1, 2, 3};
Key traits:

O(1) random access
Amortized O(1) push_back
Contiguous memory layout

Question 32 Cpp Programming

What is std::unordered_map?

A race condition occurs when the outcome of a program depends on the non-deterministic timing of concurrent accesses to shared data, producing different results on each run. Protect shared data with synchronization (mutex, atomics). std::unordered_map stores key-value pairs in a hash table:
std::unordered_map<std::string, int> m;
Provides average O(1) lookup, insertion, and deletion. Keys are not sorted. Requires a hash function for custom key types. Structured bindings unpack aggregates, pairs, tuples, and structured bindings:

auto [key, value] = *map.begin();
auto [x,y,z] = getPoint();

Replaces manual std::tie in many cases. std::array has a fixed size known at compile time and is stored on the stack:
std::array<int, 5> a = {1,2,3,4,5};
std::vector is dynamically sized and uses heap memory. Use array when the size is constant for better performance.

Question 33 Cpp Programming

What is std::variant (C++17)?

The <algorithm> header provides generic functions that work with iterators:

std::sort(v.begin(), v.end())
std::find(v.begin(), v.end(), val)
std::count_if(v.begin(), v.end(), pred)
std::transform, std::accumulate, std::for_each

A binary operator can be overloaded as a member (left operand is *this) or a non-member (often friend) taking both operands. The << stream operator is overloaded as a non-member so the left operand can be a stream. Structured bindings unpack aggregates, pairs, tuples, and structured bindings:

auto [key, value] = *map.begin();
auto [x,y,z] = getPoint();

Replaces manual std::tie in many cases. std::variant<int, std::string, double> is a type-safe union holding one of several alternative types:

std::variant<int,std::string> v = 42;
if (std::holds_alternative<int>(v)) std::get<int>(v);

Question 34 Cpp Programming

What is the purpose of the virtual destructor?

Lambda capture options:

[x] – capture x by value
[&x] – capture x by reference
[=] – capture all used variables by value
[&] – capture all by reference
[=, &x] – all by value except x by reference

std::unordered_map stores key-value pairs in a hash table:
std::unordered_map<std::string, int> m;
Provides average O(1) lookup, insertion, and deletion. Keys are not sorted. Requires a hash function for custom key types. std::chrono (in <chrono>) provides type-safe time durations and clocks:

auto start = std::chrono::steady_clock::now();
auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(start.time_since_epoch());

A virtual destructor ensures that when deleting an object through a base class pointer, the derived class destructor is called first:
virtual ~Base() { }
Without it, derived resources may leak.

Question 35 Cpp Programming

What is constexpr vs inline?

The <algorithm> header provides generic functions that work with iterators:

std::sort(v.begin(), v.end())
std::find(v.begin(), v.end(), val)
std::count_if(v.begin(), v.end(), pred)
std::transform, std::accumulate, std::for_each

std::format provides Python-like, type-safe text formatting:
std::string s = std::format("Hello, {}! You are {:.2f}", name, age);
Replaces printf with a type-safe, extensible alternative. constexpr indicates a function can be evaluated at compile time when given constant expressions.
inline allows the function to be defined in multiple translation units without violating the ODR.
A function can be both inline constexpr. RAII (Resource Acquisition Is Initialization) ties resource lifetime to object lifetime:

Resources are acquired in the constructor
Resources are released in the destructor

This guarantees cleanup even if exceptions occur.

Question 36 Cpp Programming

What is a reference and an lvalue reference?

A reference is an alias for another object. An lvalue reference (T&) binds to a named object (lvalue).
int x=5; int& r = x;
References cannot be reseated and must be initialized.

new/delete are operators that construct/destruct objects and are type-safe
malloc/free are library functions that allocate raw bytes with no construction

delete calls the destructor; free does not. Avoid mixing them. Template specialization provides a custom implementation for a specific type:
template<> class Stack<bool> { /* optimized for bool */ };
There is full specialization (one specific type) and partial specialization (subset of parameters). begin() returns a mutable iterator allowing modification of elements.
cbegin() returns a const_iterator that provides read-only access:
auto it = v.cbegin(); // *it is const

Question 37 Cpp Programming

What is the copy-and-swap idiom?

Placement new constructs an object at a specific preallocated memory address:

void* buf = ::operator new(sizeof(T));
T* obj = new (buf) T(args);
obj->~T(); ::operator delete(buf);

Used in custom allocators and memory pools. Copy-and-swap implements assignment safely by copying the source and swapping with *this using a non-throwing swap. It provides strong exception safety and reuses copy/move logic. The << operator is typically overloaded as a friend function:
friend std::ostream& operator<<(std::ostream& os, const MyClass& obj) { os << obj.data; return os; } The vtable is a static, per-class array of virtual function pointers. Each object has a vptr pointing to its class's vtable. The compiler generates the vtable at compile time; the vptr is set by every constructor.

Question 38 Cpp Programming

What is the difference between new/delete and malloc/free?

The << operator is typically overloaded as a friend function:
friend std::ostream& operator<<(std::ostream& os, const MyClass& obj) { os << obj.data; return os; } Concepts are named compile-time predicates that constrain template parameters:
template<std::integral T> T add(T a, T b) { return a+b; }
They replace most SFINAE boilerplate with clear, readable constraints.

new/delete are operators that construct/destruct objects and are type-safe
malloc/free are library functions that allocate raw bytes with no construction

delete calls the destructor; free does not. Avoid mixing them. A const member function is declared with a trailing const:
int getX() const;
It promises not to modify the object's observable state and can be called on const objects.

Question 39 Cpp Programming

What is an enum class (scoped enumeration)?

enum class (C++11) provides type-safe, scoped enumerations:
enum class Color { Red, Green, Blue };
Unlike plain enum, values don't implicitly convert to integers and don't pollute the enclosing namespace. Access with Color::Red. Implementation-defined behavior must be documented by the implementation (compiler/library) but is not specified by the standard. Examples: sizeof(int), byte order, and the value of a char after overflow. std::any is a type-safe container for a single value of any copy-constructible type:

std::any a = 42; a = std::string("hi");
auto s = std::any_cast<std::string>(a);

std::async runs a callable asynchronously and returns a std::future with the result:

auto fut = std::async(std::launch::async, []{ return 42; });
int v = fut.get();

Question 40 Cpp Programming

What is the difference between override and final specifiers?

A binary operator can be overloaded as a member (left operand is *this) or a non-member (often friend) taking both operands. The << stream operator is overloaded as a non-member so the left operand can be a stream. Brace initialization uses {} to initialize any object and prevents narrowing conversions:

int x{5}; // OK
int y{3.14}; // ERROR: narrowing

It is the recommended initialization syntax in modern C++. std::list is a doubly-linked list:

O(1) insertion and deletion anywhere (given an iterator)
No random access (no operator[])
Higher memory overhead per element due to pointers

override (C++11) asserts that a method overrides a base virtual; the compiler errors otherwise.
final prevents further overriding in derived classes (or prevents further derivation when applied to a class).

Question 41 Cpp Programming

What is std::pair and std::tuple?

Multiple inheritance allows a class to inherit from more than one base class:
class C : public A, public B { };
It can cause the diamond problem, resolved with virtual inheritance. std::lock_guard is a lightweight RAII lock with no extra features.
std::unique_lock additionally supports deferred locking, manual unlock, and ownership transfer (movable). Use unique_lock when you need that flexibility. Include guards (or #pragma once) prevent a header from being processed more than once per translation unit:

#ifndef FOO_H
#define FOO_H
// ...
#endif

Avoids multiple-definition errors from repeated inclusion. std::pair holds two values: std::pair<int,string> p = {1, "hi"}; accessed via p.first, p.second.
std::tuple holds any number of values: auto t = std::make_tuple(1, 2.0, "hi"); accessed via std::get<0>(t).

Question 42 Cpp Programming

What is a static class member?

std::set is an ordered container of unique elements implemented as a balanced BST:
std::set<int> s = {3, 1, 2};
Elements are always sorted. Insertion, lookup, and deletion are all O(log n). begin() returns a mutable iterator allowing modification of elements.
cbegin() returns a const_iterator that provides read-only access:
auto it = v.cbegin(); // *it is const A static class member belongs to the class itself rather than any object. There is exactly one copy shared by all instances. It must be defined in a single translation unit:
int MyClass::count = 0; std::span<T> is a non-owning view over a contiguous sequence, like a safe pointer-plus-size pair:

void process(std::span<int> s);
process(std::vector<int>{1,2,3});

Question 43 Cpp Programming

What is std::stringstream?

A range-based for loop iterates over all elements of a container:
for (const auto& elem : vec) { std::cout << elem; }
It works with any type that provides begin() and end() iterators. Use & to avoid copies. std::stringstream is an in-memory string buffer supporting <</>> like streams:
std::stringstream ss; ss << "x=" << 42; auto s = ss.str();
Useful for parsing and building strings. A class template defines a blueprint for a class parameterized by types:
template<typename T> class Stack { std::vector<T> data; public: void push(T val); T pop(); };
Used as Stack<int> s;. enum class (C++11) provides type-safe, scoped enumerations:
enum class Color { Red, Green, Blue };
Unlike plain enum, values don't implicitly convert to integers and don't pollute the enclosing namespace. Access with Color::Red.

Question 44 Cpp Programming

What is the difference between std::move and std::forward?

An rvalue reference, declared with &&, binds to temporary objects (rvalues):
void process(std::string&& s);
It enables move semantics by allowing you to "steal" resources from objects that are about to be destroyed. The <algorithm> header provides generic functions that work with iterators:

std::sort(v.begin(), v.end())
std::find(v.begin(), v.end(), val)
std::count_if(v.begin(), v.end(), pred)
std::transform, std::accumulate, std::for_each

constexpr declares that a variable or function can be evaluated at compile time:

constexpr int square(int x) { return x*x; }
constexpr int s = square(5);

In C++14+ it may contain loops and conditionals; C++20 added consteval (must be compile-time). std::move unconditionally casts to an rvalue reference (always treat as movable).
std::forward conditionally casts based on the template type T, preserving the original value category. Neither actually moves at runtime; both are casts.

Question 45 Cpp Programming

What is a default constructor?

An rvalue reference, declared with &&, binds to temporary objects (rvalues):
void process(std::string&& s);
It enables move semantics by allowing you to "steal" resources from objects that are about to be destroyed. A default constructor is one that can be called with no arguments. It is generated by the compiler only if no other constructor is declared. You can force its creation with = default:
MyClass() = default; std::launder(p) obtains a pointer to an object occupying memory whose lifetime was revived by placement new. It blocks the compiler from assuming the pointer still refers to the old object. Structured bindings unpack aggregates, pairs, tuples, and structured bindings:

auto [key, value] = *map.begin();
auto [x,y,z] = getPoint();

Replaces manual std::tie in many cases.

Question 46 Cpp Programming

What is static_cast in C++?

static_cast performs compile-time type conversions with type checking:
double d = 3.14; int i = static_cast<int>(d);
Safer than C-style casts. Used for: numeric conversions, upcasting in inheritance, and void* to typed pointer conversions. Placement new constructs an object at a specific preallocated memory address:

void* buf = ::operator new(sizeof(T));
T* obj = new (buf) T(args);
obj->~T(); ::operator delete(buf);

Used in custom allocators and memory pools. A mutable member can be modified even inside const member functions:
mutable int cache_;
Useful for lazy initialization, caches, and mutexes. std::mutex provides mutual exclusion for protecting shared data:
std::lock_guard<std::mutex> lk(m); /* critical section */
Always use RAII lock guards (lock_guard, unique_lock, scoped_lock) to avoid forgetting unlock().

Question 47 Cpp Programming

What is the Rule of Zero?

SFINAE (Substitution Failure Is Not An Error) means that when substituting template parameters fails, the compiler silently removes that overload rather than aborting. It's the basis of type traits and many compile-time checks. noexcept declares that a function will not throw exceptions:
void process() noexcept { }
If a noexcept function does throw, std::terminate is called. It helps the compiler optimize code and is important for move operations. An assertion is a runtime check of an invariant. assert(expr) (in <cassert>) aborts the program with a message if expr is false. Define NDEBUG to disable assertions in release builds. The Rule of Zero says: if your class uses only RAII types (smart pointers, STL containers) for resource management, you should not define any special member functions. The compiler-generated defaults will be correct.

Question 48 Cpp Programming

What is a condition variable?

std::enable_if<Cond, T> yields T when Cond is true, and is otherwise ill-formed (SFINAE):
template<typename T> typename std::enable_if<std::is_integral<T>::value, T>::type f(T);
std::void_t<...> detects valid expressions in trait detectors. A mutable member can be modified even inside const member functions:
mutable int cache_;
Useful for lazy initialization, caches, and mutexes. A std::condition_variable allows threads to wait until notified that a predicate is satisfied:
std::unique_lock<std::mutex> lk(m); cv.wait(lk, []{ return ready; });
Used to implement blocking queues and other synchronization patterns. The Rule of Five states that if a class defines any of these, it should define all five:

Destructor
Copy constructor
Copy assignment operator
Move constructor
Move assignment operator

This ensures correct resource management.

Question 49 Cpp Programming

What is placement new?

An abstract class has at least one pure virtual function and cannot be instantiated.
A concrete class implements all inherited pure virtuals and can be instantiated. std::string is a class managing a heap-allocated, resizable character sequence with bounds-checked operations.
A C-style string is a const char* pointing to a null-terminated array with no size and no safety. Prefer std::string in C++. Placement new constructs an object at a specific preallocated memory address:

void* buf = ::operator new(sizeof(T));
T* obj = new (buf) T(args);
obj->~T(); ::operator delete(buf);

Used in custom allocators and memory pools. The std namespace contains the entire C++ Standard Library, including containers, algorithms, and I/O classes. You access its members with std:: prefix, e.g., std::cout, std::vector.

Question 50 Cpp Programming

What is the difference between declaration and definition?

this is a hidden pointer available in non-static member functions, pointing to the object on which the function was called. Its type is ClassName* const (or const ClassName* in const member functions). A declaration introduces a name and its type:
extern int x; void foo(int);
A definition provides the storage/function body:
int x = 5; void foo(int) { }
Definitions are also declarations; declarations may appear many times. std::shared_ptr allows shared ownership via reference counting:
auto p = std::make_shared<int>(42);
The managed object is deleted when the last shared_ptr owning it is destroyed. Use p.use_count() to check the count. Initialization happens in the member initializer list (or default member initializer) and uses member initialization.
Assignment happens in the constructor body, where the member is first default-constructed then overwritten. Prefer initialization for efficiency.