C++ CPP key terms

The container’s relevant allocated element capacity under its contract, distinct from the number of currently constructed elements reported by size.

A range including its beginning and excluding its end, whose end iterator is a boundary and not automatically a dereferenceable element.

The loss of a previously usable iterator/reference relationship after an operation under the actual container contract, requiring renewed validation before use.

A comparator relationship satisfying the relevant consistency properties required by ordered algorithms/containers, rather than a casually chosen less-than-or-equal test.

The returned boundary of retained algorithm results after operations such as remove, which does not itself reduce the container’s element count.

The inference of template arguments according to declared parameter relationships and language rules, without inventing arbitrary conversions to reconcile every mixed call.

A lambda arrangement storing the relevant captured value in the closure object, whose later mutable state need not change the original variable.

The value-category conversion associated with std::move, which enables relevant overload selection but does not by itself execute a resource transfer.

The flags, formatting and error conditions affecting subsequent supported input/output operations, which require interpretation alongside types and supplied data.

A throw expression without an operand inside a handler that rethrows the currently handled exception rather than constructing a sliced base copy.

The language-defined relationship among evaluations and side effects, distinct from operator precedence or the visual left-to-right layout of an expression.

A defined integral arithmetic operation whose fractional part is discarded under its language rules, distinct from floating-point division performed after a conversion.

The conditional skipping of a logical operator’s right operand when the left operand already determines the result under the relevant language rules.

The selection among candidate function declarations using argument and conversion rules, not merely choosing a function with a preferred return type.

A condition for which the language imposes no defined behavioral requirements, which cannot be repaired by reporting a plausible output from one run.

The period in which a particular object exists under the language rules, which a retained pointer or allocated storage does not automatically extend.

An ownership technique tying resource management to an object’s lifetime and destructor behavior, supporting appropriate cleanup on scope exit and exception unwinding.

A destructor supporting the relevant dynamic destruction behavior through a base interface in ordinary polymorphic deletion, distinct from another unrelated virtual method.

A pointer value that no longer designates a live usable object in its relevant context, despite retaining an address-like representation.

The organization of object state and operations behind an interface and access rules, without turning class access control into encryption or process isolation.