50 C++ Interview Questions and Answers

A pointer is a variable that stores the memory address of another variable.

In C++, the members of a struct are public by default, while in a class they are private by default.

A constructor is a special member function of a class that initializes objects of the class.

The 'this' pointer is used to refer to the calling object of a member function.

Function overloading allows multiple functions with the same name but different parameter lists.

'new' initializes objects and calls constructors, while 'malloc' only allocates memory.

The 'virtual' keyword is used to enable runtime polymorphism in C++.

'delete' is used for single objects, while 'delete[]' is used for arrays.

A reference is an alias for another variable, providing an alternative name for it.

The 'friend' keyword allows a function or class to access private and protected members of another class.

A shallow copy copies the values of the object, while a deep copy duplicates the objects pointed to by the pointers.

The Rule of Three states that if a class requires a user-defined destructor, copy constructor, or copy assignment operator, it likely requires all three.

'override' ensures a method overrides a base class method, while 'final' prevents further overriding of a method or class.

A pure virtual function is a function declared in a base class that must be overridden in derived classes.

'const' defines a variable as constant, while 'constexpr' ensures compile-time evaluation.

A lambda function is an anonymous function defined using the '[]' syntax.

'std::vector' is dynamic in size, while 'std::array' has a fixed size.

RAII (Resource Acquisition Is Initialization) is a programming idiom where resource allocation is tied to object lifetime.

'std::shared_ptr' allows multiple ownership, while 'std::unique_ptr' allows only single ownership.

'std::move' enables transferring ownership of resources, facilitating move semantics.

'std::map' is ordered and implemented as a balanced tree, while 'std::unordered_map' is unordered and implemented as a hash table.

'throw' raises exceptions, 'noexcept' specifies functions that do not throw, and 'try-catch' handles exceptions.

'inline' suggests inlining a function, while 'constexpr' ensures compile-time evaluation.

'std::async' is used to run a function asynchronously in a separate thread.

'std::list' is a doubly linked list, while 'std::deque' is a double-ended queue.

'std::function' is a wrapper for callable objects like functions, lambdas, and functors.

'std::mutex' provides mutual exclusion, while 'std::lock_guard' manages the locking and unlocking of a mutex.

'std::weak_ptr' does not contribute to the reference count, preventing circular references.

'std::bind' creates a callable object by binding arguments to a function.

'emplace_back' constructs an object in place, while 'push_back' copies or moves an existing object.

SFINAE (Substitution Failure Is Not An Error) is a C++ template metaprogramming feature that allows invalid substitutions in templates to be ignored.

'std::enable_if' is used for SFINAE-based template specialization, while 'std::is_same' checks type equality.

Template specialization allows customizing the behavior of a template for a specific type.

A variadic template allows a template to accept a variable number of arguments.

'decltype' is used to deduce the type of an expression at compile time.

'lvalue' references refer to named objects, while 'rvalue' references refer to temporary objects.

'std::forward' is used to preserve the value category (lvalue or rvalue) of a forwarded argument.

A metaprogram is a program that generates or manipulates other programs at compile time using templates.

'static_assert' checks conditions at compile time, while 'assert' checks conditions at runtime.

'std::tuple' is a fixed-size collection of heterogeneous values.

'std::optional' represents an optional value, while 'std::variant' holds one value from a set of types.

'std::any' is a type-safe container for single values of any type.

'std::atomic' ensures atomic operations, while 'volatile' prevents compiler optimizations on a variable.

'std::filesystem' provides utilities for file and directory manipulation.

'std::promise' sets a value or exception, while 'std::future' retrieves the result asynchronously.

'std::chrono' provides utilities for time manipulation and measurement.

'std::allocator' is the default memory allocator, while custom allocators allow specialized memory management.

'std::execution' provides execution policies for parallel algorithms.

'std::shared_mutex' allows multiple readers or one writer, while 'std::mutex' allows only one thread at a time.

'std::scoped_lock' provides a convenient way to lock multiple mutexes simultaneously.