[definitions] - C++17 → C++20

Files changed (1) hide show

tmp/tmp648zem_n/{from.md → to.md} +180 -75

tmp/tmp648zem_n/{from.md → to.md} RENAMED Viewed

@@ -1,131 +1,236 @@
 ## Definitions <a id="definitions">[[definitions]]</a>
-[*Note 1*: Clause [[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 2*: Every arbitrary-positional stream is also a repositional
-stream. — *end note*]
-\defncontext{Clauses~ [[strings]], [[localization]], [[input.output]], and~ [[re]]}
-any object which, when treated sequentially, can represent text
-[*Note 3*: 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 4*: 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 5*: 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
-any specific behavior provided by the implementation, within the scope
-of the *required behavior*
-a description of *replacement function* and *handler function* semantics
-a direct-initialization ([[dcl.init]]) that is not
-list-initialization ([[dcl.init.list]])
-a *non-reserved function* whose definition may be provided by a
-C++program
-[*Note 6*: 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 7*: 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()`
-a class member function ([[class.mfct]]) that accesses the state of an
 object of the class but does not alter that state
-[*Note 8*: 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 9*: 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 10*: 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 11*: 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 12*: 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 13*: 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
-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 1*: If an object `x` of type `std::vector<int>` is in a valid
 but unspecified state, `x.empty()` can be called unconditionally, and

 ## Definitions <a id="definitions">[[definitions]]</a>
+[*Note 1*: [[intro.defs]] defines additional terms used elsewhere in
+this document. — *end note*]
+#### 1 arbitrary-positional stream <a id="defns.arbitrary.stream">[[defns.arbitrary.stream]]</a>
+stream (described in [[input.output]]) that can seek to any integral
+position within the length of the stream
+[*Note 1 to entry*: Every arbitrary-positional stream is also a
+repositional stream. — *end note*]
+#### 2 character <a id="defns.character">[[defns.character]]</a>
+⟨[[strings]], [[localization]], [[input.output]], and~ [[re]]⟩
+object which, when treated sequentially, can represent text
+[*Note 1 to entry*: The term does not mean only `char`, `char8_t`,
+`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*]
+#### 3 character container type <a id="defns.character.container">[[defns.character.container]]</a>
+class or a type used to represent a character
+[*Note 1 to entry*: It is used for one of the template parameters of
+the string, iostream, and regular expression class
+templates. — *end note*]
+#### 4 comparison function <a id="defns.comparison">[[defns.comparison]]</a>
+operator function [[over.oper]] for any of the equality [[expr.eq]],
+relational [[expr.rel]], or three-way comparison [[expr.spaceship]]
+operators
+#### 5 component <a id="defns.component">[[defns.component]]</a>
+group of library entities directly related as members, parameters, or
 return types
+[*Note 1 to entry*: 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*]
+#### 6 constant subexpression <a id="defns.const.subexpr">[[defns.const.subexpr]]</a>
+expression whose evaluation as subexpression of a
+*conditional-expression* `CE` [[expr.cond]] would not prevent `CE` from
+being a core constant expression [[expr.const]]
+#### 7 deadlock <a id="defns.deadlock">[[defns.deadlock]]</a>
+situation wherein 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
+#### 8 default behavior <a id="defns.default.behavior.impl">[[defns.default.behavior.impl]]</a>
+⟨implementation⟩ specific behavior provided by the implementation,
+within the scope of the required behavior
+#### 9 default behavior <a id="defns.default.behavior.func">[[defns.default.behavior.func]]</a>
+⟨specification⟩ description of replacement function and handler function
+semantics
+#### 10 direct-non-list-initialization <a id="defns.direct-non-list-init">[[defns.direct-non-list-init]]</a>
+direct-initialization [[dcl.init]] that is not list-initialization
+[[dcl.init.list]]
+#### 11 expression-equivalent <a id="defns.expression-equivalent">[[defns.expression-equivalent]]</a>
+expressions that all have the same effects, either are all
+potentially-throwing [[except.spec]] or are all not
+potentially-throwing, and either are all constant subexpressions or are
+all not constant subexpressions
+[*Example 1*: For a value `x` of type `int` and a function `f` that
+accepts integer arguments, the expressions `f(x + 2)`, `f(2 + x)`, and
+`f(1 + x + 1)` are expression-equivalent. — *end example*]
+#### 12 handler function <a id="defns.handler">[[defns.handler]]</a>
+non-reserved function whose definition may be provided by a C++ program
+[*Note 1 to entry*: 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
+[[support]]. — *end note*]
+#### 13 implementation-defined strict total order over pointers <a id="defns.order.ptr">[[defns.order.ptr]]</a>
+*implementation-defined* strict total ordering over all pointer values
+such that the ordering is consistent with the partial order imposed by
+the builtin operators `<`, `>`, `<=`, `>=`, and `<=>`
+#### 14 iostream class templates <a id="defns.iostream.templates">[[defns.iostream.templates]]</a>
+templates, defined in [[input.output]], that take two template arguments
+[*Note 1 to entry*: 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*]
+#### 15 modifier function <a id="defns.modifier">[[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
+#### 16 move assignment <a id="defns.move.assign">[[defns.move.assign]]</a>
 assignment of an rvalue of some object type to a modifiable lvalue of
 the same type
+#### 17 move construction <a id="defns.move.constr">[[defns.move.constr]]</a>
 direct-initialization of an object of some type with an rvalue of the
 same type
+#### 18 NTCTS <a id="defns.ntcts">[[defns.ntcts]]</a>
+sequence of values that have character type that precede the terminating
+null character type value `charT()`
+#### 19 observer function <a id="defns.observer">[[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 1 to entry*: Observer functions are specified as `const` member
+functions [[class.this]]. — *end note*]
+#### 20 program-defined specialization <a id="defns.prog.def.spec">[[defns.prog.def.spec]]</a>
+explicit template specialization or partial specialization that is not
+part of the C++ standard library and not defined by the implementation
+#### 21 program-defined type <a id="defns.prog.def.type">[[defns.prog.def.type]]</a>
+non-closure class type or enumeration type that is not part of the C++
+standard library and not defined by the implementation, or a closure
+type of a non-implementation-provided lambda expression, or an
+instantiation of a program-defined specialization
+[*Note 1 to entry*: Types defined by the implementation include
+extensions [[intro.compliance]] and internal types used by the
+library. — *end note*]
+#### 22 projection <a id="defns.projection">[[defns.projection]]</a>
+⟨function object argument⟩ transformation that an algorithm applies
+before inspecting the values of elements
+[*Example 1*:
+``` cpp
+std::pair<int, std::string_view> pairs[] = {{2, "foo"}, {1, "bar"}, {0, "baz"}};
+std::ranges::sort(pairs, std::ranges::less{}, [](auto const& p) { return p.first; });
+```
+sorts the pairs in increasing order of their `first` members:
+``` cpp
+{{0, "baz"}, {1, "bar"}, {2, "foo"}}
+```
+— *end example*]
+#### 23 referenceable type <a id="defns.referenceable">[[defns.referenceable]]</a>
+type that is either an object type, a function type that does not have
+cv-qualifiers or a *ref-qualifier*, or a reference type
+[*Note 1 to entry*: The term describes a type to which a reference can
+be created, including reference types. — *end note*]
+#### 24 replacement function <a id="defns.replacement">[[defns.replacement]]</a>
+non-reserved function whose definition is provided by a C++ program
+[*Note 1 to entry*: 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*]
+#### 25 repositional stream <a id="defns.repositional.stream">[[defns.repositional.stream]]</a>
+stream (described in [[input.output]]) that can seek to a position that
+was previously encountered
+#### 26 required behavior <a id="defns.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 1 to entry*: If such a function defined in a C++ program fails
+to meet the required behavior when it executes, the behavior is
+undefined.  — *end note*]
+#### 27 reserved function <a id="defns.reserved.function">[[defns.reserved.function]]</a>
+function, specified as part of the C++ standard library, that is defined
+by the implementation
+[*Note 1 to entry*: If a C++ program provides a definition for any
+reserved function, the results are undefined.  — *end note*]
+#### 28 stable algorithm <a id="defns.stable">[[defns.stable]]</a>
+algorithm that preserves, as appropriate to the particular algorithm,
 the order of elements
+[*Note 1 to entry*: Requirements for stable algorithms are given in
 [[algorithm.stable]]. — *end note*]
+#### 29 traits class <a id="defns.traits">[[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
+#### 30 valid but unspecified state <a id="defns.valid">[[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 1*: If an object `x` of type `std::vector<int>` is in a valid
 but unspecified state, `x.empty()` can be called unconditionally, and

Diff to HTML by rtfpessoa