20 Library introduction [library]

20.3 Definitions [definitions]

1
#
[ Note
:
Clause [intro.defs] defines additional terms used elsewhere in this International Standard.
— end note
 ]

20.3.1 arbitrary-positional stream [defns.arbitrary.stream]

a stream (described in Clause [input.output]) that can seek to any integral position within the length of the stream
[ Note
:
Every arbitrary-positional stream is also a repositional stream.
— end note
 ]

20.3.2 character [defns.character]

⟨Clauses [strings], [localization], [input.output], and [re]⟩ any object which, when treated sequentially, can represent text
[ Note
:
The term does not mean only char, char16_­t, char32_­t, and wchar_­t objects, but any value that can be represented by a type that provides the definitions specified in these Clauses.
— end note
 ]

20.3.3 character container type [defns.character.container]

a class or a type used to represent a character
[ Note
:
It is used for one of the template parameters of the string, iostream, and regular expression class templates.
A character container type is a POD ([basic.types]) type.
— end note
 ]

20.3.4 comparison function [defns.comparison]

an operator function ([over.oper]) for any of the equality ([expr.eq]) or relational ([expr.rel]) operators

20.3.5 component [defns.component]

a group of library entities directly related as members, parameters, or return types
[ Note
:
For example, the class template basic_­string and the non-member function templates that operate on strings are referred to as the string component.
— end note
 ]

20.3.6 constant subexpression [defns.const.subexpr]

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

20.3.7 deadlock [defns.deadlock]

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

20.3.8 default behavior [defns.default.behavior.impl]

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

20.3.9 default behavior [defns.default.behavior.func]

⟨specification⟩ a description of replacement function and handler function semantics

20.3.10 direct-non-list-initialization [defns.direct-non-list-init]

a direct-initialization ([dcl.init]) that is not list-initialization ([dcl.init.list])

20.3.11 handler function [defns.handler]

a non-reserved function whose definition may be provided by a C++ program
[ Note
:
A C++ program may designate a handler function at various points in its execution by supplying a pointer to the function when calling any of the library functions that install handler functions (Clause [language.support]).
— end note
 ]

20.3.12 iostream class templates [defns.iostream.templates]

templates, defined in Clause [input.output], that take two template arguments
[ Note
:
The arguments are named charT and traits.
The argument charT is a character container class, and the argument traits is a class which defines additional characteristics and functions of the character type represented by charT necessary to implement the iostream class templates.
— end note
 ]

20.3.13 modifier function [defns.modifier]

a class member function ([class.mfct]) other than a constructor, assignment operator, or destructor that alters the state of an object of the class

20.3.14 move assignment [defns.move.assign]

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

20.3.15 move construction [defns.move.constr]

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

20.3.16 NTCTS [defns.ntcts]

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

20.3.17 observer function [defns.observer]

a class member function ([class.mfct]) that accesses the state of an object of the class but does not alter that state
[ Note
:
Observer functions are specified as const member functions ([class.this]).
— end note
 ]

20.3.18 referenceable type [defns.referenceable]

an object type, a function type that does not have cv-qualifiers or a ref-qualifier, or a reference type
[ Note
:
The term describes a type to which a reference can be created, including reference types.
— end note
 ]

20.3.19 replacement function [defns.replacement]

a non-reserved function whose definition is provided by a C++ program
[ Note
:
Only one definition for such a function is in effect for the duration of the program's execution, as the result of creating the program ([lex.phases]) and resolving the definitions of all translation units ([basic.link]).
— end note
 ]

20.3.20 repositional stream [defns.repositional.stream]

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

20.3.21 required behavior [defns.required.behavior]

a 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
[ Note
:
If such a function defined in a C++ program fails to meet the required behavior when it executes, the behavior is undefined.
— end note
 ]

20.3.22 reserved function [defns.reserved.function]

a function, specified as part of the C++ standard library, that must be defined by the implementation
[ Note
:
If a C++ program provides a definition for any reserved function, the results are undefined.
— end note
 ]

20.3.23 stable algorithm [defns.stable]

an algorithm that preserves, as appropriate to the particular algorithm, the order of elements
[ Note
:
Requirements for stable algorithms are given in [algorithm.stable].
— end note
 ]

20.3.24 traits class [defns.traits]

a 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

20.3.25 valid but unspecified state [defns.valid]

a 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
[ Example
:
If an object x of type std​::​vector<int> is in a valid but unspecified state, x.empty() can be called unconditionally, and x.front() can be called only if x.empty() returns false.
— end example
 ]