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

Files changed (1) hide show

tmp/tmp8tzjrb1c/{from.md → to.md} +0 -239

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

@@ -1,239 +0,0 @@
-## 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
-`x.front()` can be called only if `x.empty()` returns
-`false`. — *end example*]

Diff to HTML by rtfpessoa