[ Note: [intro.defs] defines additional terms used elsewhere in this International Standard. — end note ]
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 ]
⟨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 ]
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 ]
an operator function ([over.oper]) for any of the equality ([expr.eq]) or relational ([expr.rel]) operators
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 ]
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])
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⟩ any specific behavior provided by the implementation, within the scope of the required behavior
⟨specification⟩ a description of replacement function and handler function semantics
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 ]
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 ]
a class member function ([class.mfct]) 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
a sequence of values that have character type that precede the terminating null character type value charT()
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 ]
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 ]
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 ]
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 ]
a stream (described in Clause [input.output]) that can seek to a position that was previously encountered
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 ]
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 ]
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 ]
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
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 ]