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
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 ]
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 ]
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
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 ]
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
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 ]
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 ]
17.3.20 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 ]
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 ]
RetroSearch is an open source project built by @garambo | Open a GitHub Issue
Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo
HTML:
3.2
| Encoding:
UTF-8
| Version:
0.7.4