16 Library introduction [library]

stream (described in [input.output]) that can seek to any integral position within the length of the stream

⟨[strings], [localization], [input.output], and [re]⟩ object which, when treated sequentially, can represent text

class or a type used to represent a character

operator function ([over.oper]) for any of the equality ([expr.eq]), relational ([expr.rel]), or three-way comparison ([expr.spaceship]) operators

group of library entities directly related as members, parameters, or return types

expression whose evaluation as subexpression of a conditional-expression CE ([expr.cond]) would not prevent CE from being a core constant expression

situation wherein one or more threads are unable to continue execution because each is blocked waiting for one or more of the others to satisfy some condition

⟨implementation⟩ specific behavior provided by the implementation, within the scope of the required behavior

⟨specification⟩ description of replacement function and handler function semantics

direct-initialization that is not list-initialization

expressions that all have the same effects, either are all potentially-throwing ([except.spec]) or are all not potentially-throwing, and either are all constant subexpressions or are all not constant subexpressions

non-reserved function whose definition may be provided by a C++ program

implementation-defined strict total ordering over all pointer values such that the ordering is consistent with the partial order imposed by the builtin operators <, >, <=, >=, and <=>

templates, defined in [input.output], that take two template arguments

class member function other than a constructor, assignment operator, or destructor that alters the state of an object of the class

assignment of an rvalue of some object type to a modifiable lvalue of the same type

direct-initialization of an object of some type with an rvalue of the same type

sequence of values that have character type that precede the terminating null character type value charT()

class member function that accesses the state of an object of the class but does not alter that state

explicit template specialization or partial specialization that is not part of the C++ standard library and not defined by the implementation

non-closure class type or enumeration type that is not part of the C++ standard library and not defined by the implementation, or a closure type of a non-implementation-provided lambda expression, or an instantiation of a program-defined specialization

⟨function object argument⟩ transformation that an algorithm applies before inspecting the values of elements

std::pair<int, std::string_view> pairs[] = {{2, "foo"}, {1, "bar"}, {0, "baz"}};
std::ranges::sort(pairs, std::ranges::less{}, [](auto const& p) { return p.first; });

{{0, "baz"}, {1, "bar"}, {2, "foo"}}

type that is either an object type, a function type that does not have cv-qualifiers or a ref-qualifier, or a reference type

non-reserved function whose definition is provided by a C++ program

stream (described in [input.output]) that can seek to a position that was previously encountered

description of replacement function and handler function semantics applicable to both the behavior provided by the implementation and the behavior of any such function definition in the program

function, specified as part of the C++ standard library, that is defined by the implementation

algorithm that preserves, as appropriate to the particular algorithm, the order of elements

class that encapsulates a set of types and functions necessary for class templates and function templates to manipulate objects of types for which they are instantiated

value of an object that is not specified except that the object's invariants are met and operations on the object behave as specified for its type