17 Library introduction [library]

17.3 Definitions [definitions]

17.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 ]

17.3.2 block [defns.block]

place a thread in the blocked state

17.3.3 blocked thread [defns.blocked]

a thread that is waiting for some condition (other than the availability of a processor) to be satisfied before it can continue execution160

This definition is taken from POSIX.

17.3.4 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 ]

17.3.5 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 ]

17.3.6 comparison function [defns.comparison]

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

17.3.7 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 ]

17.3.8 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

17.3.9 default behavior [defns.default.behavior.impl]

<implementation> any specific behavior provided by the implementation, within the scope of the required behavior

17.3.10 default behavior [defns.default.behavior.func]

<specification> a description of replacement function and handler function semantics

17.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 ]

17.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 ]

17.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

17.3.14 move construction [defns.move.constr]

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

17.3.15 move assignment [defns.move.assign]

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

17.3.16 object state [defns.obj.state]

the current value of all non-static class members of an object ([class.mem])
Note: The state of an object can be obtained by using one or more observer functions.  — end note ]

17.3.17 NTCTS [defns.ntcts]

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

17.3.18 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 ]

17.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 ]

17.3.20 repositional stream [defns.repositional.stream]

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

17.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 ]

17.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 ]

17.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 ]

17.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
Note: Traits classes defined in Clauses [strings], [localization] and [input.output] are character traits, which provide the character handling support needed by the string and iostream classes.  — end note ]

17.3.25 unblock [defns.unblock]

place a thread in the unblocked state

17.3.26 valid but unspecified state [defns.valid]

an object state 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 ]