Variables

auto deduces the type from the initialiser by template-argument-deduction rules; top-level const/& are dropped — use const auto& to keep them. C++14 added auto return type. decltype(auto) keeps the exact type. C++20 auto parameters make abbreviated templates.

enum (unscoped) leaks enumerators into the enclosing scope and converts implicitly to int. enum class (scoped, C++11) keeps them in their own scope and does not convert implicitly — static_cast is required. Both allow a custom underlying type.

extern has two uses: (1) declaring a variable or function defined in another TU so the linker resolves its address; (2) extern "C" suppresses name mangling for C interop. Without extern, a namespace-scope variable declaration is also a definition, breaking ODR across TUs.

Fundamental types: void, bool, characters (char, wchar_t, char8/16/32_t), integers (short/int/long/long long, signed/unsigned), floating-point (float, double, long double). Sizes are implementation-defined; <cstdint> gives fixed-width aliases like int32_t.

An lvalue is a named, addressable expression that outlives the expression. An rvalue is a temporary without a stable address. An xvalue (expiring) is a named object cast to rvalue ref via std::move. Overloads prefer T&& over const T& for rvalues, enabling moves.

const int and int const are the same type. With pointers: const T* rebinds but pointee is read-only; T* const is fixed but pointee is mutable; const T* const locks both. A reference is a non-null alias that cannot be rebound. Pointers usually take a machine word.

volatile tells the compiler the variable may change outside program control (hardware, signal handlers, setjmp); it must not cache or reorder reads/writes. NOT a synchronisation primitive: no cross-thread ordering. Use std::atomic for thread safety.

const means the value cannot be modified through that reference, but it need not be known at compile time. constexpr means it must be computable at compile time and is implicitly const. Use constexpr for compile-time constants; const for runtime-immutable values.

A temporary lives until the end of the full expression. Binding const T& or T&& extends its lifetime to the reference's lifetime. Extension does not propagate through function params, member init, or std::move. Returning a local by const& is UB.

Most float/double use IEEE 754: sign bit, biased exponent, significand. Many decimal fractions are not exactly representable in binary, so arithmetic accumulates rounding error; == is unreliable.

C++17 allows an init-statement in if/switch: if (auto it = map.find(key); it != map.end()) { ... }. The init-variable is scoped to the whole if/else block. It avoids polluting the enclosing scope and pairs well with RAII guards.

int8_t is an exact-width signed 8-bit type guaranteed by the standard. char may be signed or unsigned depending on the platform and compiler flags.

A namespace groups related names to avoid collisions. An anonymous namespace gives contents internal linkage — like static at file scope but also for types/classes. Nested ones use :: or using. C++17 allows namespace A::B::C { ... }.

Use std::numeric_limits<T> from <limits>: ::max(), ::lowest(). For integers min() is the most negative; for floats min() is the smallest positive normalised value — use lowest() for the most negative float. C macros like INT_MAX work but are not generic.

Range-for is sugar over begin()/end(): it advances an iterator until end(). Works for any type providing begin/end (member or free via ADL). No built-in index without std::views::enumerate (C++23); mutating the container invalidates the iterator (UB).

On a local, static gives static storage duration: initialised once on first pass and lives until program exit. On a global or function, it changes external linkage to internal — invisible outside the TU. Two unrelated uses of the same keyword.

sizeof(T) returns the size in bytes including padding. The compiler aligns each field to its natural alignment and adds trailing padding so array elements stay aligned; total is a multiple of the struct's largest alignment. Use offsetof or #pragma pack to inspect or override layout.

An aggregate is a class with no user-provided constructors, no private/protected data members, and no virtual functions or virtual bases; T x{a,b,c}; initialises members in declaration order with value-initialisation for unlisted ones.

auto follows template-type-deduction rules: refs and top-level const are stripped; arrays and functions decay to pointers. So auto x = v[0]; copies even if it looks lightweight. decltype(auto) preserves the exact declared type including references.

Const correctness means marking every variable, parameter, and method that doesn't modify state as const. It catches accidental mutations, allows zero-cost const& parameters, and only const-qualified methods may be called on const objects.

decltype(name) gives the declared type exactly (with refs/cv). decltype((name)) adds & since the parenthesised name is an lvalue expression. auto strips refs and top-level cv unless &/const is added. decltype(auto) (C++14) deduces by decltype rules.

Every distinct object must have a unique address; sizeof == 0 would let two objects share one. So the standard requires sizeof(T) >= 1. Exception: Empty Base Optimisation — an empty class used as a base may take zero space inside the derived object.

Each member sits at an offset that's a multiple of alignof(T); padding fills gaps and the struct aligns to the largest member. Reorder largest-first to shrink. [[no_unique_address]] (C++20) lets empty members share storage; #pragma pack overrides alignment.

static has four uses: (1) static storage for locals (lazy init); (2) internal linkage for globals/functions; (3) class members shared across instances; (4) static-local in methods. SIOF: init order of non-local statics across TUs is undefined — A may use uninitialised B.

auto [a, b, c] = expr; decomposes a tuple-like value (aggregate, std::pair, std::tuple, or class with get<I> + tuple_size) into named variables. auto& for refs, const auto& for const views. Each binding's type is deduced from its source member.

thread_local T x; gives each thread its own x, initialised on first use, destroyed at thread exit. Used for per-thread caches, RNGs, error state. Cost: extra indirection per access (TLS slot); shared libraries may require __tls_get_addr.

UB means the standard places no constraints on what the program may do; the compiler may assume UB never occurs and optimise accordingly. Examples: signed overflow, null/dangling deref, out-of-bounds, uninitialised reads, data races. Not a runtime error — debug may pass, release may fail.

Uniform init (C++11) uses {} everywhere and bans narrowing (int x{3.14} is an error). Aggregate init applies when a class has no user ctors, no private/protected non-static members, no virtuals, no non-public bases — T obj{a, b, c} then fills members in order without a ctor.

Default-init T x; leaves built-ins indeterminate (UB to read) and calls the default ctor for classes. Value-init T x{}/T() zeros built-ins; for a class without a user-provided ctor it zeros members then runs the generated ctor. Zero-init is a separate stage for namespace-scope objects.

constexpr means a function may run during constant evaluation — or at runtime, depending on arguments. consteval (C++20) makes a function immediate: every call must evaluate at compile time. constinit (C++20) forces compile-time initialization of a static variable, killing the init order fiasco, but the variable stays mutable.

A narrowing conversion is an implicit conversion that may lose information — floating-point to integer, a wider to a narrower type, or a value not representable in the target. C++ forbids narrowing inside brace initialization: int x{3.5}; is ill-formed while int x = 3.5; compiles.

std::variant<A,B,C> is a type-safe tagged union holding one value from a fixed compile-time set; access via std::get<T> or std::visit. std::any is a type-erased container with the set open at runtime. Use variant for known alternatives; any for dynamic types.

A 66 B. c prints as the character A. In c + 1 the char is promoted to int, so the result is 66, printed as a number. Casting back with char(c + 1) makes it a char again, so the stream prints 'B' (ASCII 66).

2 2.5 1. 5 / 2 is integer division and truncates toward zero. 5.0 / 2 promotes the int to double, giving 2.5. % is the integer remainder. Note -7 % 3 is -1 in C++ — the result's sign follows the dividend.

Undefined behavior: i is modified twice (i++ and ++i) and read with no sequence point separating the side effects, so the standard imposes no result — different compilers print different values and the program is invalid.

A bit-field is a member with colon and bit count: unsigned int flags : 3;. Compiler packs them into storage units. Ordering inside a unit is implementation-defined; a zero-width unnamed field forces a new unit; you cannot take a bit-field's address.

Through C++14 the operand evaluation order of << was unspecified, so it could print 2 1 0 or 0 1 2. C++17 made << operands evaluate left to right, so it now reliably prints 0 1 2. General function-argument order is still unspecified — avoid such side effects.

When a declaration could parse as a function or as object init, C++ picks the function. T x(MyArg()); looks like construction but parses as a function x taking a pointer-to-function-returning-MyArg. Fix with brace init: T x{MyArg{}}; or a named argument.

int arithmetic overflows for large squares, and signed overflow is undefined behavior (not wraparound), so a[i] * a[i] and the accumulating int sum can both overflow silently. Fix: use a wider type — long long sum and static_cast<long long>(a[i]) * a[i].

0 (false). In a mixed comparison the int is converted to unsigned, so -1 becomes a huge value (UINT_MAX), which is not less than 1. This usual-arithmetic-conversion trap also breaks for (size_t i = v.size() - 1; i >= 0; --i).

typedef/alias gives a new name, not a new type: typedef int UserId; lets UserId and OrderId mix freely. A strong typedef wraps the type in a distinct class: struct UserId { int v; }; (or boost::strong_typedef). C++ has no native syntax — composition is the idiom.

An aggregate is an array or a class with no user-declared constructors, no private non-static data members, and no virtual functions. Brace-init fills members in declaration order; omitted trailing members are value-initialized. C++20 adds designated initializers (.x = 1).

A reference dangles when the object it binds to is destroyed while the reference still lives — using it is undefined behaviour. Binding a const T& to a temporary extends that temporary to the reference's scope. But extension applies only to the direct binding: returning the reference does not extend it.

Strict aliasing says a stored value may be accessed only through an lvalue of its own type, a compatible type, or char. Reading a float through an int* is undefined behaviour, so the optimizer assumes such pointers never overlap and may reorder or drop loads. The safe tools are std::memcpy and std::bit_cast.

ASCII is 7-bit, 128 characters. Unicode assigns code points to every character; UTF-8 is variable 1–4 bytes and ASCII-compatible, UTF-16 is 2 or 4 bytes.

Six bitwise operators: & (AND), | (OR), ^ (XOR), ~ (NOT), <</>> (shifts). Boolean algebra: AND/OR/NOT identities (De Morgan: ~(A & B) == ~A | ~B). Idioms: set x |= 1 << n, clear x &= ~(1 << n), test (x >> n) & 1.

A trivial type has compiler-provided, non-virtual special members — no user logic runs on copy or destruction. Only trivially copyable types may be memcpy'd: the byte copy yields a valid object since there are no invariants to preserve. memcpy'ing a std::string is undefined behaviour.