C++

C++ is a powerful, general-purpose programming language used in systems software, games, embedded devices, high-performance servers, and many large applications. It supports multiple styles of programming—procedural, object-oriented, and generic—so you can write both low-level efficient code and high-level abstractions.

Every C++ program starts from the main function. A minimal example prints text and returns 0 to indicate success.

#include <iostream>

int main() {
    std::cout << "Hello, world!\n";
    return 0;
}

C focuses on procedural programming and stays close to hardware. C++ keeps that power and adds classes, templates, RAII, stronger type features, and a larger standard library for safer, more expressive code.

A namespace organizes code and prevents name collisions by grouping related identifiers under a named scope.

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

Putting it in a header affects every file that includes that header. This pollutes the global namespace and increases the chance of symbol conflicts.

std::cout is the standard output stream used to print formatted output to the console.

std::cin is the standard input stream used to read formatted input from the user or another input source.

A declaration introduces a variable name and type, and may also initialize it.

int x = 5;

Common fundamental types include bool, char, int, float, double, and void, plus signed/unsigned and fixed-width integer variants.

auto lets the compiler deduce a variable’s type from its initializer, reducing verbosity and keeping code consistent.

auto x = 42;      // int
auto y = 3.14;    // double

• = assigns a value to a variable
• == compares two values for equality

A reference is an alias to an existing object. It must be initialized when declared and normally cannot be rebound to another object later.

int x = 10;
int& r = x;

• Pointer: can be null, can be reseated, needs dereference syntax
• Reference: must refer to a valid object, cannot usually be reseated, simpler syntax

const marks data as read-only through that particular name/view, helping prevent accidental modification.

• const int* p: pointer to const int (cannot modify pointed value through p)
• int* const p: const pointer to int (cannot change pointer target)

A function prototype declares a function’s signature before use, enabling type checking by the compiler.

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

int f(int);
double f(double);

A default argument provides a fallback value when a caller omits that parameter.

void log(int level = 1);

inline allows multiple identical definitions across translation units (often in headers) and may enable inlining optimization.

A class is a user-defined type that bundles state (data) and behavior (methods), with controlled access to internals.

They are nearly identical in capability; the key default differs:

• class defaults to private
• struct defaults to public

public, private, and protected control who can access class members.

Encapsulation means exposing a clear public interface while hiding implementation details.

A constructor initializes an object at creation time.

A destructor runs automatically when object lifetime ends, commonly to release resources.

Yes. Different constructor signatures support multiple ways to initialize objects.

It initializes members directly before entering constructor body, which is often required or more efficient.

struct S {
  int x;
  S(int v) : x(v) {}
};

Direct initialization avoids extra work and is required for const and reference members.

RAII (Resource Acquisition Is Initialization) ties resource lifetime (memory, files, locks) to object lifetime.

It guarantees cleanup automatically, reduces leaks, and improves exception safety.

Operators for manual dynamic memory allocation/deallocation. In modern C++, smart pointers and containers are preferred.

Manual ownership is error-prone (leaks, double-free, lifetime bugs). Prefer std::unique_ptr, std::shared_ptr, std::vector, etc.

nullptr is the dedicated null pointer literal (C++11+), safer than integer-like null macros.

nullptr has a proper null-pointer type and avoids overload ambiguity; NULL is often just 0 or 0L.

An array is a fixed-size contiguous block of elements of one type.

std::array provides STL compatibility, size awareness, and value semantics while staying fixed-size.

std::vector automatically manages memory, resizes dynamically, and stores elements contiguously.

std::string is an owning, dynamic text type that is safer and easier than raw C-style strings.

It offers clean, readable iteration over container elements.

for (const auto& v : vec) { /* ... */ }

It reduces repetitive type spelling and keeps declarations aligned with initializer types.

It constructs a new object from another object of the same type.

It copies one existing object’s state into another existing object.

It transfers resources from a temporary/rvalue into a newly created object.

It transfers resources from an rvalue into an already existing object.

If a class defines destructor, copy constructor, or copy assignment, it usually needs all three.

Rule of Three plus move constructor and move assignment for modern C++ resource-aware types.

Design types so compiler-generated special members are enough by using RAII members.

It requests the compiler-generated default implementation explicitly.

It forbids a function, preventing invalid usage at compile time.

MyType(const MyType&) = delete;

• Lvalue: has identity/location (can usually appear on left side of assignment)
• Rvalue: temporary/value expression (typically short-lived)

std::move casts to an rvalue expression so move operations become eligible. It does not move data by itself.

A moved-from object remains valid but its value/content is usually unspecified unless documented.

It preserves value category (lvalue/rvalue) through template forwarding with std::forward.

T&& in a deduced template context; it can bind to both lvalues and rvalues.

Exceptions are a structured error propagation system using throw, try, and catch.

In codebases with strict low-latency/real-time constraints or policies that prohibit exceptions.

During exception propagation, local objects are destroyed automatically in reverse construction order.

Throwing during unwinding may cause std::terminate, ending the program abruptly.

It states that a function is not expected to throw; violating it may terminate the program.

Containers can then use moves during reallocation, improving both performance and safety.

A template is a generic blueprint for functions or classes resolved at compile time.

A class parameterized by types/values to create reusable generic components.

A customized implementation for specific template arguments.

Specializing a class template for a subset/pattern of template parameters.

Template parameters that are values (e.g., integers, pointers, auto NTTPs in newer standards).

constexpr enables compile-time evaluation when expression context and inputs allow.

• const: value is read-only
• constexpr: value/function can participate in constant-expression contexts

A compile-time conditional, useful for selecting valid template branches.

A compile-time assertion with a readable error message when condition fails.

STL is the core generic library toolkit: containers, iterators, algorithms, and utilities.

vector, deque, list, map, unordered_map, set, unordered_set, array, string.

• map: ordered keys, predictable iteration, O(log n)
• unordered_map: hash table, average O(1), no key ordering

Iterators are generalized traversal objects used to access container elements.

cbegin/cend return const iterators, preventing element modification via iterator.

Reusable operations like sort, find, transform, copy, count_if, etc.

They are expressive, less error-prone, composable, and often optimized.

A lambda is an inline anonymous function object.

auto sq = [](int x){ return x * x; };

Capture list defines how outer variables are used inside lambda: by value, by reference, or explicit per-variable capture.

It allows modification of by-value captured variables inside the lambda body.

A type-erased callable wrapper for storing any compatible callable target.

It may add indirection and potential allocations. For hot paths, templates/auto callables can be cheaper.

std::bind creates adapted callables by binding arguments; lambdas are usually clearer in modern code.

A scoped, strongly typed enum that avoids implicit conversions and name pollution.

Better type safety, clearer intent, and reduced accidental misuse.

friend grants selected external functions/classes access to private/protected members.

Defining custom behavior for operators on user-defined types.

Operators such as &&, ||, comma, address-of, and implicit conversion operators can be surprising if misused.

It integrates custom types naturally with stream-based output.

std::ostream& operator<<(std::ostream& os, const T& t);

It prevents unintended implicit conversions from constructor argument types.

A member function that converts an object to another type; should often be explicit.

Copying a derived object by value into a base object drops derived-specific data/behavior.

Use references or pointers (preferably smart pointers) for polymorphic objects.

Inheritance creates a derived class that reuses/extents behavior of a base class.

Polymorphism allows one interface to represent different concrete behaviors.

A virtual function is dispatched at runtime based on the object’s dynamic type.

It ensures proper derived cleanup when deleting through a base-class pointer.

override asks compiler to verify that the function actually overrides a base virtual function.

void foo() override;

It blocks further overriding (for methods) or inheritance (for classes).

A class with at least one pure virtual function. It defines an interface and cannot be instantiated directly.

Multiple inheritance means a class derives from more than one base class. It is useful when a type naturally combines behaviors from separate interfaces, but it must be designed carefully to avoid ambiguity.

The diamond problem appears when two base classes inherit from the same ancestor, and a derived class inherits from both. Without special handling, the derived class may end up with duplicate base subobjects and ambiguous member access.

Virtual inheritance ensures only one shared instance of a common base exists in diamond-shaped hierarchies. It solves duplication and ambiguity caused by multiple inheritance.

Prefer composition when you want flexibility, loose coupling, and easier maintenance. Use inheritance mainly when there is a true and stable “is-a” relationship.

pImpl (Pointer to Implementation) separates interface from implementation details by storing implementation in a private pointer. This hides internal dependencies and reduces header exposure.

Main benefits are ABI stability, faster incremental builds, and cleaner encapsulation. It also helps reduce recompilation impact when implementation changes.

ODR requires certain entities (like classes, inline functions, templates) to have one consistent definition across the program. Violating ODR leads to undefined behavior and very hard-to-debug issues.

A translation unit is a source file after preprocessing (after includes/macros are expanded). Each translation unit is compiled separately before linking.

Linkage defines whether a symbol is visible across translation units. Internal linkage limits visibility to one translation unit; external linkage allows cross-file linking.

Objects with static storage duration exist for the entire lifetime of the program. They are created before main (or on first use for local statics) and destroyed at program shutdown.

Thread storage duration means each thread gets its own instance of a variable, usually with thread_local. The variable lives as long as the thread lives.

Dynamic storage duration refers to objects created at runtime (e.g., new, allocators, smart pointers). Their lifetime is controlled explicitly or by owning objects.

It is the risk that globals in different translation units initialize in unspecified order. If one global depends on another not yet initialized, behavior can fail unpredictably.

Use function-local statics (“construct on first use”), dependency injection, and avoid cross-global dependencies. These techniques make initialization order explicit and safer.

Yes. Since C++11, initialization of function-local statics is guaranteed to be thread-safe.

UB is behavior the C++ standard does not define. If UB occurs, the compiler may assume it never happens, causing arbitrary results.

Typical examples: out-of-bounds access, use-after-free, data races, signed overflow, invalid pointer casts. Even if code “seems to work,” UB can break under optimization or platform changes.

Behavior where the compiler/platform must choose a rule and document it. Example: exact sizes of some integer types on a given target.

Behavior where multiple outcomes are allowed and no single outcome must be documented for every run. The program stays valid, but exact result may vary.

Strict aliasing limits accessing an object through unrelated types. Breaking these rules can produce UB and surprising optimizer miscompilations.

Alignment is a type’s required memory boundary (e.g., 4-byte or 8-byte boundary). Proper alignment is important for correctness and performance.

alignas requests a specific alignment for a type or object.

struct alignas(64) CacheLineData { int x; };

A constexpr function can be evaluated at compile time when called with constant-expression inputs. It can also run at runtime when compile-time evaluation is not required.

A consteval function must always be evaluated at compile time. If compile-time evaluation is not possible, compilation fails.

constinit ensures a static/thread variable is initialized at compile time (constant initialization), preventing dynamic init surprises.

Concepts are template constraints that express required properties of template arguments. They improve readability and compiler diagnostics.

They produce earlier and clearer errors, make template APIs self-documenting, and reduce cryptic substitution failures.

A requires clause attaches constraints to templates/functions so they participate only when requirements are met.

SFINAE means “Substitution Failure Is Not An Error.” In older template style, invalid substitutions remove candidates instead of hard-failing compilation.

CRTP (Curiously Recurring Template Pattern) is when a class template takes the derived class as a parameter. It enables static polymorphism and compile-time customization.

• Static polymorphism: resolved at compile time (templates/CRTP), often zero-overhead
• Dynamic polymorphism: resolved at runtime via virtual dispatch

Type erasure hides concrete types behind a common interface (e.g., std::function). It improves flexibility at some runtime cost.

std::any stores one value of any copyable type with type-safe retrieval via std::any_cast.

std::variant is a type-safe tagged union storing exactly one value from a fixed set of types.

std::optional<T> represents either “a T value” or “no value,” without using pointers or magic sentinels.

It makes absence explicit in the type system, improving correctness and readability.

std::span is a lightweight non-owning view over contiguous memory (pointer + length). It is useful for passing arrays/vectors safely without copying.

std::string_view is a non-owning read-only view into character data. It avoids allocation and copying for many APIs.

Lifetime issues: if the original string/buffer dies or changes, the view may dangle and become invalid.

C++ ranges provide composable views and algorithms with pipeline-style syntax, often clearer and lazier than manual loops.

Coroutines are language-level suspend/resume functions for async workflows, generators, and cooperative tasks.

No. Coroutines are control-flow constructs; scheduling/execution (threaded or not) depends on library/runtime design.

A move-only type supports move operations but not copy operations (example: std::unique_ptr).

To enforce exclusive ownership so exactly one owner controls resource lifetime.

std::shared_ptr provides shared ownership via reference counting. The managed object is destroyed when the last owner is gone.

std::weak_ptr observes an object managed by shared_ptr without extending its lifetime.

A cycle happens when objects hold shared ownership of each other; reference counts never reach zero, so destruction never occurs.

Use std::weak_ptr in at least one direction of cyclic relationships.

They are safer and cleaner. make_shared can be more efficient due to single allocation for control block + object.

A custom deleter is a callable that defines how a smart pointer releases its resource.

• Basic guarantee: program remains valid; no leaks; invariants preserved
• Strong guarantee: operation is transactional (commit-or-rollback)
• Nothrow guarantee: operation never throws exceptions

It implements assignment by copying into a temporary and swapping. This centralizes logic and often provides strong exception safety.

An allocator controls how container memory is allocated/deallocated. It is a policy customization point for memory behavior.

For domain-specific performance, reduced fragmentation, custom pools, and memory tracking/constraints.

PMR (<memory_resource>) provides runtime-selectable allocation strategies without changing container element types.

It means arranging data to improve locality so CPU caches are used effectively, reducing stalls and misses.

False sharing occurs when different threads write unrelated variables on the same cache line, causing heavy coherence traffic.

Use padding/alignment, separate hot writable fields, and shard per-thread data.

It defines rules for atomic operations, synchronization, visibility, and ordering between threads.

relaxed, acquire, release, acq_rel, seq_cst (and consume, rarely used in practice). They trade off ordering guarantees vs performance.

When only atomicity is needed and no cross-thread ordering/synchronization is required.

It provides a single global order for sequentially consistent operations, making mental models simpler.

Conflicting unsynchronized accesses to the same memory location (at least one write, non-atomic) cause UB.

No. volatile is not a synchronization primitive. Use atomics, mutexes, and condition variables.

A mutex enforces mutual exclusion so only one thread enters a critical section at a time.

std::lock_guard is an RAII lock wrapper: locks on construction, unlocks on destruction.

std::unique_lock is a flexible lock wrapper supporting deferred locking, manual unlock/relock, and condition-variable waits.

Deadlock is when threads wait on each other indefinitely due to cyclic lock dependencies.

Keep consistent lock ordering, reduce lock nesting, and use helpers like std::scoped_lock for multi-lock acquisition.

A synchronization primitive that blocks threads until notified and a condition becomes true.

Predicates protect against spurious wakeups and re-check correctness on wake.

cv.wait(lock, [&]{ return ready; });

They provide asynchronous result passing: producer sets result in promise, consumer gets it through future.

Launch policy matters. Without explicit std::launch::async, execution may be deferred until get()/wait().

Correctness is very hard: memory ordering, ABA, reclamation, and subtle race bugs make design complex.

A CAS check sees value A again and assumes nothing changed, even though state changed A→B→A in between.

They are strategies for safe memory reclamation in lock-free structures, preventing reclamation while data may still be observed.

Modules are a modern alternative to textual headers, improving compile scalability and dependency hygiene.

Faster builds, better encapsulation, and less macro/definition leakage across boundaries.

It manages compilation units, dependencies, flags, linking, and test/build orchestration across environments.

Warnings catch bugs early, enforce consistency, and improve long-term code quality.

A common baseline is -Wall -Wextra -Wpedantic plus stricter project-specific flags.

Different compilers expose different warnings, optimizations, and edge-case behavior, revealing hidden portability bugs.

• ASan: memory safety errors
• UBSan: undefined behavior checks
• TSan: data race detection
• MSan: uninitialized read detection (where supported)

Fuzzing finds rare edge-case crashes and logic bugs by generating many unexpected inputs automatically.

Microbenchmarks can mislead when they do not represent real workloads or ignore compiler/runtime effects.

PGO uses real execution profiles to guide optimization decisions like inlining and branch layout.

LTO enables whole-program optimization at link stage, improving inlining and cross-module optimization opportunities.

Devirtualization replaces virtual calls with direct calls when the compiler can prove concrete type, reducing dispatch overhead.

Changing exported layouts/signatures/symbols can break already-compiled client binaries.

Use pImpl, minimize exposed details, manage symbol versions carefully, and apply strict semantic versioning discipline.

ABI details can differ across compilers/standard library implementations, risking binary incompatibility.

Strong typedef wraps primitive types in distinct types to prevent semantic mix-ups (e.g., UserId vs OrderId).

Value-semantics objects own their state and behave like independent values when copied/moved.

It simplifies reasoning, reduces aliasing/lifetime errors, and often improves API clarity.

Abstractions should not impose runtime cost beyond what equivalent hand-written low-level code would pay.

Make ownership explicit, keep interfaces small, use const-correctness, avoid raw owning pointers, and choose expressive types.

Yes for non-owning/nullable observation when semantically right, but ownership and lifetime rules must be clearly documented.

Expert code stays correct under complexity, expresses ownership/lifetimes clearly, performs measurably, and remains maintainable.

Modernize incrementally: introduce RAII, smart pointers, safer containers/APIs, add tests/sanitizers, then refactor in small verified steps.

1. Define clear contracts and invariants
2. Build the simplest correct design first
3. Enable strict warnings and static checks
4. Add tests, fuzzing, and sanitizers
5. Profile before optimizing
6. Review for UB, lifetime, and concurrency risks
7. Document assumptions and performance boundaries