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 ]
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.
<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 ]
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
direct-initialization of an object of some type with an rvalue of the same type
assignment of an rvalue of some object type to a modifiable lvalue of the same type
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 sequence of values that have character type that precede the terminating null character type value charT()
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 ]
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
[ 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 ]
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 ]