Functions

By value: cheap-to-copy types (two or three machine words) or when you need a copy. By const T&: read-only types costlier to copy. By T&: to modify the caller's object. By T*: when null is meaningful.

Undefined behavior: count dies at return, so c refers to a dead variable

Anonymous function object created inline. Captures: [=] value, [&] ref, [x]/[&x], [y = expr] init, [*this] copy. Captureless converts to a function pointer.

Multiple functions share a name but differ in parameter types or count. The compiler picks the best match: exact type, promotions, standard conversions, user-defined conversions.

The lambda captures count by reference ([&]), but count is destroyed when makeCounter returns, so calling the returned std::function reads a dangling reference — UB. Fix: capture by value, [count]() mutable { return ++count; }.

Default arguments must be listed right-to-left (trailing first). Resolved at the call site using the declaration visible there, not the definition.

The order is unspecified and differs between compilers. Since C++17 each argument is evaluated completely before another starts, so f(a++, a++) — UB before C++17 — just passes a and a+1 in some order.

1 5

0

double

1 10

Holds the address of a function with a specific signature. Declaration: int (*fp)(double, double);. Call: fp(a, b). Use using BinaryOp = int(*)(double, double); for readability.

&& and || evaluate the left operand first; if the result is determined, the right is skipped. Standard-guaranteed and sequenced. The ternary ? : also short-circuits. Overloaded &&/|| do NOT.

Per-call area for local variables, saved registers, return address, spilled arguments. Stack overflow happens when nested calls or large locals exceed the stack limit.

ADL adds the namespaces of a call's argument types to the set searched for an unqualified function name. It lets swap(a, b) or operator<< find the right overload without a qualifier. It surprises you by silently pulling in an unintended overload from an argument's namespace.

auto f() { return expr; } deduces the return type by the same rules as auto x = expr. All returns must yield the same type. Recursion only after the first return.

Permits compile-time evaluation with constant args; otherwise runs at runtime. C++11 — single return. C++14 — loops, locals. C++20 — virtual, allocations, std::vector/std::string.

Defaults bind statically by the static type of the pointer/reference. Base* b = new Derived; b->f(); uses Base's default though Derived::f runs — the override's = 2 is dead.

A functor (function object) is any class that overloads operator(). Unlike a function pointer, it carries state in members and inlines — no type-erasure overhead.

inline suppresses ODR so the same definition can appear in multiple TUs — useful for header functions. The expansion hint is mostly ignored by modern compilers.

By default a lambda's operator() is const, so value captures can't be modified. mutable removes that const. Capturing this stores a pointer — dangles if the object dies first.

Mangling encodes signatures (parameters, namespaces, templates) into the symbol name so the linker distinguishes overloads. Each ABI has its own scheme. extern "C" disables mangling for C interop.

Two indirections: load vptr, load function pointer from vtable, jump. Cost is a few ns plus a possible cache miss; more importantly the call cannot be inlined.

Preserves value category (lvalue/rvalue) and cv-qualification when forwarding args. Pattern: template<class... A> void wrap(A&&... a) { f(std::forward<A>(a)...); }. Without forward, rvalues become lvalues.

A

Obligations between caller and callee. Preconditions — caller must satisfy. Postconditions — callee guarantees. Invariants — properties holding after every public op.

A generic lambda (C++14) uses auto for a parameter, making its operator() a member template. Each distinct argument type instantiates a separate operator(), exactly like a function template. The closure is one type; only the call operator is templated and adapts per call site.

An init-capture (C++14) introduces a new closure member with an initializer: [p = std::move(ptr)]. Plain [ptr] only copies; the capture syntax cannot express a move. Init-capture lets you initialize the member from any expression — moving a unique_ptr in, or computing a fresh value.

Store callbacks as std::vector<std::function<void()>> keyed by token, and iterate on emit(). Lambdas with captures fit naturally — std::function type-erases the closure.

std::mem_fn(&Class::method) adapts a member-function pointer into a callable taking the object first. Useful with STL algorithms; modern code prefers a lambda.

auto f(args) -> ReturnType puts the return type after the parameter list. Required when the return type depends on params: auto add(T a, U b) -> decltype(a + b). Still needed for SFINAE-friendly templates.

C-style ... with va_list is type-unsafe — callee guesses types via format string or sentinel; mismatches cause UB. C++11 variadic templates template<class... A> are type-safe — each arg keeps its type.

noexcept(expr) evaluates expr at compile time and propagates the bool into the noexcept spec. Pattern: swap(T&, T&) noexcept(noexcept(swap(a.m, b.m))).

The C++ standard does not require TCO. GCC/Clang/MSVC do tail-call optimisation when the recursive call is the last op at -O2/-O3, with no destructors after and compatible ABI.

INVOKE is the standard's abstract rule for calling any callable. std::invoke(f, args...) applies it uniformly: it calls free functions and functors as f(args...), but for a pointer-to-member it treats the first argument as the object, handling references, pointers, and reference_wrapper. It underpins std::bind, std::thread, and std::function.

consteval (C++20) marks a function as immediate — every call must yield a constant expression. Unlike constexpr, no runtime fallback. Used for compile-time-only utilities.

C++23 lets a member take this as an explicit parameter: void f(this Self&& self, ...). Templated on value category and cv-qualification — replaces four overloads. Enables CRTP without inheritance.