[basic.start] - C++17 → C++20

Files changed (1) hide show

tmp/tmpymuvtmz3/{from.md → to.md} +470 -98

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

@@ -1,98 +1,92 @@
-## Start and termination <a id="basic.start">[[basic.start]]</a>
-### `main` function <a id="basic.start.main">[[basic.start.main]]</a>
-A program shall contain a global function called `main`. Executing a
-program starts a main thread of execution ([[intro.multithread]],
-[[thread.threads]]) in which the `main` function is invoked, and in
-which variables of static storage duration might be initialized (
-[[basic.start.static]]) and destroyed ([[basic.start.term]]). It is
-*implementation-defined* whether a program in a freestanding environment
-is required to define a `main` function.
-[*Note 1*: In a freestanding environment, start-up and termination is
-*implementation-defined*; start-up contains the execution of
-constructors for objects of namespace scope with static storage
-duration; termination contains the execution of destructors for objects
-with static storage duration. — *end note*]
 An implementation shall not predefine the `main` function. This function
 shall not be overloaded. Its type shall have C++ language linkage and it
 shall have a declared return type of type `int`, but otherwise its type
 is *implementation-defined*. An implementation shall allow both
 - a function of `()` returning `int` and
 - a function of `(int`, pointer to pointer to `char)` returning `int`
-as the type of `main` ([[dcl.fct]]). In the latter form, for purposes
-of exposition, the first function parameter is called `argc` and the
-second function parameter is called `argv`, where `argc` shall be the
-number of arguments passed to the program from the environment in which
-the program is run. If `argc` is nonzero these arguments shall be
-supplied in `argv[0]` through `argv[argc-1]` as pointers to the initial
-characters of null-terminated multibyte strings (NTMBS s) (
-[[multibyte.strings]]) and `argv[0]` shall be the pointer to the initial
 character of a NTMBS that represents the name used to invoke the program
 or `""`. The value of `argc` shall be non-negative. The value of
 `argv[argc]` shall be 0.
 [*Note 2*: It is recommended that any further (optional) parameters be
 added after `argv`. — *end note*]
-The function `main` shall not be used within a program. The linkage (
-[[basic.link]]) of `main` is *implementation-defined*. A program that
 defines `main` as deleted or that declares `main` to be `inline`,
-`static`, or `constexpr` is ill-formed. The `main` function shall not be
-declared with a *linkage-specification* ([[dcl.link]]). A program that
-declares a variable `main` at global scope or that declares the name
-`main` with C language linkage (in any namespace) is ill-formed. The
-name `main` is not otherwise reserved.
 [*Example 1*: Member functions, classes, and enumerations can be called
 `main`, as can entities in other namespaces. — *end example*]
 Terminating the program without leaving the current block (e.g., by
-calling the function `std::exit(int)` ([[support.start.term]])) does
-not destroy any objects with automatic storage duration (
-[[class.dtor]]). If `std::exit` is called to end a program during the
-destruction of an object with static or thread storage duration, the
-program has undefined behavior.
-A return statement in `main` has the effect of leaving the main function
-(destroying any objects with automatic storage duration) and calling
-`std::exit` with the return value as the argument. If control flows off
-the end of the *compound-statement* of `main`, the effect is equivalent
-to a `return` with operand `0` (see also [[except.handle]]).
-### Static initialization <a id="basic.start.static">[[basic.start.static]]</a>
 Variables with static storage duration are initialized as a consequence
 of program initiation. Variables with thread storage duration are
 initialized as a consequence of thread execution. Within each of these
 phases of initiation, initialization occurs as follows.
-A *constant initializer* for a variable or temporary object `o` is an
-initializer whose full-expression is a constant expression, except that
-if `o` is an object, such an initializer may also invoke constexpr
-constructors for `o` and its subobjects even if those objects are of
-non-literal class types.
-[*Note 1*: Such a class may have a non-trivial
-destructor. — *end note*]
 *Constant initialization* is performed if a variable or temporary object
-with static or thread storage duration is initialized by a constant
-initializer for the entity. If constant initialization is not performed,
-a variable with static storage duration ([[basic.stc.static]]) or
-thread storage duration ([[basic.stc.thread]]) is zero-initialized (
-[[dcl.init]]). Together, zero-initialization and constant initialization
-are called *static initialization*; all other initialization is *dynamic
-initialization*. All static initialization strongly happens before (
-[[intro.races]]) any dynamic initialization.
-[*Note 2*: The dynamic initialization of non-local variables is
 described in  [[basic.start.dynamic]]; that of local static variables is
 described in  [[stmt.dcl]]. — *end note*]
 An implementation is permitted to perform the initialization of a
 variable with static or thread storage duration as a static
@@ -105,11 +99,11 @@ statically, provided that
 - the static version of the initialization produces the same value in
   the initialized variable as would be produced by the dynamic
   initialization if all variables not required to be initialized
   statically were initialized dynamically.
-[*Note 3*:
 As a consequence, if the initialization of an object `obj1` refers to an
 object `obj2` of namespace scope potentially requiring dynamic
 initialization and defined later in the same translation unit, it is
 unspecified whether the value of `obj2` used will be the value of the
@@ -126,11 +120,11 @@ double d2 = d1;     // unspecified:
 double d1 = fd();   // may be initialized statically or dynamically to 1.0
 ```
 — *end note*]
-### Dynamic initialization of non-local variables <a id="basic.start.dynamic">[[basic.start.dynamic]]</a>
 Dynamic initialization of a non-local variable with static storage
 duration is unordered if the variable is an implicitly or explicitly
 instantiated specialization, is partially-ordered if the variable is an
 inline variable that is not an implicitly or explicitly instantiated
@@ -138,23 +132,33 @@ specialization, and otherwise is ordered.
 [*Note 1*: An explicitly specialized non-inline static data member or
 variable template specialization has ordered
 initialization. — *end note*]
 Dynamic initialization of non-local variables `V` and `W` with static
 storage duration are ordered as follows:
-- If `V` and `W` have ordered initialization and `V` is defined before
- `W` within a single translation unit, the initialization of `V` is
- sequenced before the initialization of `W`.
-- If `V` has partially-ordered initialization, `W` does not have
- unordered initialization, and `V` is defined before `W` in every
- translation unit in which `W` is defined, then
-  - if the program starts a thread ([[intro.multithread]]) other than
-    the main thread ([[basic.start.main]]), the initialization of `V`
- strongly happens before the initialization of `W`;
-  - otherwise, the initialization of `V` is sequenced before the
     initialization of `W`.
 - Otherwise, if the program starts a thread other than the main thread
   before either `V` or `W` is initialized, it is unspecified in which
   threads the initializations of `V` and `W` occur; the initializations
   are unsequenced if they occur in the same thread.
@@ -162,20 +166,20 @@ storage duration are ordered as follows:
   sequenced.
 [*Note 2*: This definition permits initialization of a sequence of
 ordered variables concurrently with another sequence. — *end note*]
-A *non-initialization odr-use* is an odr-use ([[basic.def.odr]]) not
 caused directly or indirectly by the initialization of a non-local
 static or thread storage duration variable.
 It is *implementation-defined* whether the dynamic initialization of a
 non-local non-inline variable with static storage duration is sequenced
 before the first statement of `main` or is deferred. If it is deferred,
 it strongly happens before any non-initialization odr-use of any
 non-inline function or non-inline variable defined in the same
-translation unit as the variable to be initialized. [^11] It is
 *implementation-defined* in which threads and at which points in the
 program such deferred dynamic initialization occurs.
 [*Note 3*: Such points should be chosen in a way that allows the
 programmer to avoid deadlocks. — *end note*]
@@ -234,32 +238,29 @@ odr-use by *t* of any non-inline variable with thread storage duration
 defined in the same translation unit as the variable to be initialized.
 It is *implementation-defined* in which threads and at which points in
 the program such deferred dynamic initialization occurs.
 If the initialization of a non-local variable with static or thread
-storage duration exits via an exception, `std::terminate` is called (
-[[except.terminate]]).
-### Termination <a id="basic.start.term">[[basic.start.term]]</a>
-Destructors ([[class.dtor]]) for initialized objects (that is, objects
-whose lifetime ([[basic.life]]) has begun) with static storage
-duration, and functions registered with `std::atexit`, are called as
-part of a call to `std::exit` ([[support.start.term]]). The call to
-`std::exit` is sequenced before the invocations of the destructors and
-the registered functions.
-[*Note 1*: Returning from `main` invokes `std::exit` (
-[[basic.start.main]]). — *end note*]
-Destructors for initialized objects with thread storage duration within
-a given thread are called as a result of returning from the initial
-function of that thread and as a result of that thread calling
-`std::exit`. The completions of the destructors for all initialized
-objects with thread storage duration within that thread strongly happen
-before the initiation of the destructors of any object with static
-storage duration.
 If the completion of the constructor or dynamic initialization of an
 object with static storage duration strongly happens before that of
 another, the completion of the destructor of the second is sequenced
 before the initiation of the destructor of the first. If the completion
@@ -270,12 +271,12 @@ destructor of the first. If an object is initialized statically, the
 object is destroyed in the same order as if the object was dynamically
 initialized. For an object of array or class type, all subobjects of
 that object are destroyed before any block-scope object with static
 storage duration initialized during the construction of the subobjects
 is destroyed. If the destruction of an object with static or thread
-storage duration exits via an exception, `std::terminate` is called (
-[[except.terminate]]).
 If a function contains a block-scope object of static or thread storage
 duration that has been destroyed and the function is called during the
 destruction of an object with static or thread storage duration, the
 program has undefined behavior if the flow of control passes through the
@@ -283,26 +284,26 @@ definition of the previously destroyed block-scope object. Likewise, the
 behavior is undefined if the block-scope object is used indirectly
 (i.e., through a pointer) after its destruction.
 If the completion of the initialization of an object with static storage
 duration strongly happens before a call to `std::atexit` (see
-`<cstdlib>`,  [[support.start.term]]), the call to the function passed
-to `std::atexit` is sequenced before the call to the destructor for the
 object. If a call to `std::atexit` strongly happens before the
 completion of the initialization of an object with static storage
 duration, the call to the destructor for the object is sequenced before
 the call to the function passed to `std::atexit`. If a call to
 `std::atexit` strongly happens before another call to `std::atexit`, the
 call to the function passed to the second `std::atexit` call is
 sequenced before the call to the function passed to the first
 `std::atexit` call.
 If there is a use of a standard library object or function not permitted
-within signal handlers ([[support.runtime]]) that does not happen
-before ([[intro.multithread]]) completion of destruction of objects
-with static storage duration and execution of `std::atexit` registered
-functions ([[support.start.term]]), the program has undefined behavior.
 [*Note 2*: If there is a use of an object with static storage duration
 that does not happen before the object’s destruction, the program has
 undefined behavior. Terminating every thread before a call to
 `std::exit` or the exit from `main` is sufficient, but not necessary, to
@@ -311,5 +312,376 @@ static-storage-duration objects. — *end note*]
 Calling the function `std::abort()` declared in `<cstdlib>` terminates
 the program without executing any destructors and without calling the
 functions passed to `std::atexit()` or `std::at_quick_exit()`.

+### Start and termination <a id="basic.start">[[basic.start]]</a>
+#### `main` function <a id="basic.start.main">[[basic.start.main]]</a>
+A program shall contain a global function called `main` attached to the
+global module. Executing a program starts a main thread of execution (
+[[intro.multithread]], [[thread.threads]]) in which the `main` function
+is invoked, and in which variables of static storage duration might be
+initialized [[basic.start.static]] and destroyed [[basic.start.term]].
+It is *implementation-defined* whether a program in a freestanding
+environment is required to define a `main` function.
+[*Note 1*: In a freestanding environment, startup and termination is
+*implementation-defined*; startup contains the execution of constructors
+for objects of namespace scope with static storage duration; termination
+contains the execution of destructors for objects with static storage
+duration. — *end note*]
 An implementation shall not predefine the `main` function. This function
 shall not be overloaded. Its type shall have C++ language linkage and it
 shall have a declared return type of type `int`, but otherwise its type
 is *implementation-defined*. An implementation shall allow both
 - a function of `()` returning `int` and
 - a function of `(int`, pointer to pointer to `char)` returning `int`
+as the type of `main` [[dcl.fct]]. In the latter form, for purposes of
+exposition, the first function parameter is called `argc` and the second
+function parameter is called `argv`, where `argc` shall be the number of
+arguments passed to the program from the environment in which the
+program is run. If `argc` is nonzero these arguments shall be supplied
+in `argv[0]` through `argv[argc-1]` as pointers to the initial
+characters of null-terminated multibyte strings (NTMBSs)
+[[multibyte.strings]] and `argv[0]` shall be the pointer to the initial
 character of a NTMBS that represents the name used to invoke the program
 or `""`. The value of `argc` shall be non-negative. The value of
 `argv[argc]` shall be 0.
 [*Note 2*: It is recommended that any further (optional) parameters be
 added after `argv`. — *end note*]
+The function `main` shall not be used within a program. The linkage
+[[basic.link]] of `main` is *implementation-defined*. A program that
 defines `main` as deleted or that declares `main` to be `inline`,
+`static`, or `constexpr` is ill-formed. The function `main` shall not be
+a coroutine [[dcl.fct.def.coroutine]]. The `main` function shall not be
+declared with a *linkage-specification* [[dcl.link]]. A program that
+declares a variable `main` at global scope, or that declares a function
+`main` at global scope attached to a named module, or that declares the
+name `main` with C language linkage (in any namespace) is ill-formed.
+The name `main` is not otherwise reserved.
 [*Example 1*: Member functions, classes, and enumerations can be called
 `main`, as can entities in other namespaces. — *end example*]
 Terminating the program without leaving the current block (e.g., by
+calling the function `std::exit(int)` [[support.start.term]]) does not
+destroy any objects with automatic storage duration [[class.dtor]]. If
+`std::exit` is called to end a program during the destruction of an
+object with static or thread storage duration, the program has undefined
+behavior.
+A `return` statement [[stmt.return]] in `main` has the effect of leaving
+the main function (destroying any objects with automatic storage
+duration) and calling `std::exit` with the return value as the argument.
+If control flows off the end of the *compound-statement* of `main`, the
+effect is equivalent to a `return` with operand `0` (see also
+[[except.handle]]).
+#### Static initialization <a id="basic.start.static">[[basic.start.static]]</a>
 Variables with static storage duration are initialized as a consequence
 of program initiation. Variables with thread storage duration are
 initialized as a consequence of thread execution. Within each of these
 phases of initiation, initialization occurs as follows.
 *Constant initialization* is performed if a variable or temporary object
+with static or thread storage duration is constant-initialized
+[[expr.const]]. If constant initialization is not performed, a variable
+with static storage duration [[basic.stc.static]] or thread storage
+duration [[basic.stc.thread]] is zero-initialized [[dcl.init]].
+Together, zero-initialization and constant initialization are called
+*static initialization*; all other initialization is *dynamic
+initialization*. All static initialization strongly happens before
+[[intro.races]] any dynamic initialization.
+[*Note 1*: The dynamic initialization of non-local variables is
 described in  [[basic.start.dynamic]]; that of local static variables is
 described in  [[stmt.dcl]]. — *end note*]
 An implementation is permitted to perform the initialization of a
 variable with static or thread storage duration as a static
 - the static version of the initialization produces the same value in
   the initialized variable as would be produced by the dynamic
   initialization if all variables not required to be initialized
   statically were initialized dynamically.
+[*Note 2*:
 As a consequence, if the initialization of an object `obj1` refers to an
 object `obj2` of namespace scope potentially requiring dynamic
 initialization and defined later in the same translation unit, it is
 unspecified whether the value of `obj2` used will be the value of the
 double d1 = fd();   // may be initialized statically or dynamically to 1.0
 ```
 — *end note*]
+#### Dynamic initialization of non-local variables <a id="basic.start.dynamic">[[basic.start.dynamic]]</a>
 Dynamic initialization of a non-local variable with static storage
 duration is unordered if the variable is an implicitly or explicitly
 instantiated specialization, is partially-ordered if the variable is an
 inline variable that is not an implicitly or explicitly instantiated
 [*Note 1*: An explicitly specialized non-inline static data member or
 variable template specialization has ordered
 initialization. — *end note*]
+A declaration `D` is *appearance-ordered* before a declaration `E` if
+- `D` appears in the same translation unit as `E`, or
+- the translation unit containing `E` has an interface dependency on the
+  translation unit containing `D`,
+in either case prior to `E`.
 Dynamic initialization of non-local variables `V` and `W` with static
 storage duration are ordered as follows:
+- If `V` and `W` have ordered initialization and the definition of `V`
+ is appearance-ordered before the definition of `W`, or if `V` has
+ partially-ordered initialization, `W` does not have unordered
+  initialization, and for every definition `E` of `W` there exists a
+ definition `D` of `V` such that `D` is appearance-ordered before `E`,
+  then
+  - if the program does not start a thread [[intro.multithread]] other
+ than the main thread [[basic.start.main]] or `V` and `W` have
+ ordered initialization and they are defined in the same translation
+    unit, the initialization of `V` is sequenced before the
+    initialization of `W`;
+  - otherwise, the initialization of `V` strongly happens before the
     initialization of `W`.
 - Otherwise, if the program starts a thread other than the main thread
   before either `V` or `W` is initialized, it is unspecified in which
   threads the initializations of `V` and `W` occur; the initializations
   are unsequenced if they occur in the same thread.
   sequenced.
 [*Note 2*: This definition permits initialization of a sequence of
 ordered variables concurrently with another sequence. — *end note*]
+A *non-initialization odr-use* is an odr-use [[basic.def.odr]] not
 caused directly or indirectly by the initialization of a non-local
 static or thread storage duration variable.
 It is *implementation-defined* whether the dynamic initialization of a
 non-local non-inline variable with static storage duration is sequenced
 before the first statement of `main` or is deferred. If it is deferred,
 it strongly happens before any non-initialization odr-use of any
 non-inline function or non-inline variable defined in the same
+translation unit as the variable to be initialized. [^29] It is
 *implementation-defined* in which threads and at which points in the
 program such deferred dynamic initialization occurs.
 [*Note 3*: Such points should be chosen in a way that allows the
 programmer to avoid deadlocks. — *end note*]
 defined in the same translation unit as the variable to be initialized.
 It is *implementation-defined* in which threads and at which points in
 the program such deferred dynamic initialization occurs.
 If the initialization of a non-local variable with static or thread
+storage duration exits via an exception, the function `std::terminate`
+is called [[except.terminate]].
+#### Termination <a id="basic.start.term">[[basic.start.term]]</a>
+Constructed objects [[dcl.init]] with static storage duration are
+destroyed and functions registered with `std::atexit` are called as part
+of a call to `std::exit` [[support.start.term]]. The call to `std::exit`
+is sequenced before the destructions and the registered functions.
+[*Note 1*: Returning from `main` invokes `std::exit`
+[[basic.start.main]]. — *end note*]
+Constructed objects with thread storage duration within a given thread
+are destroyed as a result of returning from the initial function of that
+thread and as a result of that thread calling `std::exit`. The
+destruction of all constructed objects with thread storage duration
+within that thread strongly happens before destroying any object with
+static storage duration.
 If the completion of the constructor or dynamic initialization of an
 object with static storage duration strongly happens before that of
 another, the completion of the destructor of the second is sequenced
 before the initiation of the destructor of the first. If the completion
 object is destroyed in the same order as if the object was dynamically
 initialized. For an object of array or class type, all subobjects of
 that object are destroyed before any block-scope object with static
 storage duration initialized during the construction of the subobjects
 is destroyed. If the destruction of an object with static or thread
+storage duration exits via an exception, the function `std::terminate`
+is called [[except.terminate]].
 If a function contains a block-scope object of static or thread storage
 duration that has been destroyed and the function is called during the
 destruction of an object with static or thread storage duration, the
 program has undefined behavior if the flow of control passes through the
 behavior is undefined if the block-scope object is used indirectly
 (i.e., through a pointer) after its destruction.
 If the completion of the initialization of an object with static storage
 duration strongly happens before a call to `std::atexit` (see
+`<cstdlib>`, [[support.start.term]]), the call to the function passed to
+`std::atexit` is sequenced before the call to the destructor for the
 object. If a call to `std::atexit` strongly happens before the
 completion of the initialization of an object with static storage
 duration, the call to the destructor for the object is sequenced before
 the call to the function passed to `std::atexit`. If a call to
 `std::atexit` strongly happens before another call to `std::atexit`, the
 call to the function passed to the second `std::atexit` call is
 sequenced before the call to the function passed to the first
 `std::atexit` call.
 If there is a use of a standard library object or function not permitted
+within signal handlers [[support.runtime]] that does not happen before
+[[intro.multithread]] completion of destruction of objects with static
+storage duration and execution of `std::atexit` registered functions
+[[support.start.term]], the program has undefined behavior.
 [*Note 2*: If there is a use of an object with static storage duration
 that does not happen before the object’s destruction, the program has
 undefined behavior. Terminating every thread before a call to
 `std::exit` or the exit from `main` is sufficient, but not necessary, to
 Calling the function `std::abort()` declared in `<cstdlib>` terminates
 the program without executing any destructors and without calling the
 functions passed to `std::atexit()` or `std::at_quick_exit()`.
+<!-- Link reference definitions -->
+[allocator.members]: utilities.md#allocator.members
+[allocator.traits.members]: utilities.md#allocator.traits.members
+[atomics]: atomics.md#atomics
+[atomics.flag]: atomics.md#atomics.flag
+[atomics.lockfree]: atomics.md#atomics.lockfree
+[atomics.order]: atomics.md#atomics.order
+[bad.alloc]: support.md#bad.alloc
+[basic]: #basic
+[basic.align]: #basic.align
+[basic.compound]: #basic.compound
+[basic.def]: #basic.def
+[basic.def.odr]: #basic.def.odr
+[basic.exec]: #basic.exec
+[basic.fundamental]: #basic.fundamental
+[basic.fundamental.width]: #basic.fundamental.width
+[basic.funscope]: #basic.funscope
+[basic.indet]: #basic.indet
+[basic.life]: #basic.life
+[basic.link]: #basic.link
+[basic.lookup]: #basic.lookup
+[basic.lookup.argdep]: #basic.lookup.argdep
+[basic.lookup.classref]: #basic.lookup.classref
+[basic.lookup.elab]: #basic.lookup.elab
+[basic.lookup.qual]: #basic.lookup.qual
+[basic.lookup.udir]: #basic.lookup.udir
+[basic.lookup.unqual]: #basic.lookup.unqual
+[basic.lval]: expr.md#basic.lval
+[basic.memobj]: #basic.memobj
+[basic.namespace]: dcl.md#basic.namespace
+[basic.pre]: #basic.pre
+[basic.scope]: #basic.scope
+[basic.scope.block]: #basic.scope.block
+[basic.scope.class]: #basic.scope.class
+[basic.scope.declarative]: #basic.scope.declarative
+[basic.scope.enum]: #basic.scope.enum
+[basic.scope.hiding]: #basic.scope.hiding
+[basic.scope.namespace]: #basic.scope.namespace
+[basic.scope.param]: #basic.scope.param
+[basic.scope.pdecl]: #basic.scope.pdecl
+[basic.scope.temp]: #basic.scope.temp
+[basic.start]: #basic.start
+[basic.start.dynamic]: #basic.start.dynamic
+[basic.start.main]: #basic.start.main
+[basic.start.static]: #basic.start.static
+[basic.start.term]: #basic.start.term
+[basic.stc]: #basic.stc
+[basic.stc.auto]: #basic.stc.auto
+[basic.stc.dynamic]: #basic.stc.dynamic
+[basic.stc.dynamic.allocation]: #basic.stc.dynamic.allocation
+[basic.stc.dynamic.deallocation]: #basic.stc.dynamic.deallocation
+[basic.stc.dynamic.safety]: #basic.stc.dynamic.safety
+[basic.stc.inherit]: #basic.stc.inherit
+[basic.stc.static]: #basic.stc.static
+[basic.stc.thread]: #basic.stc.thread
+[basic.type.qualifier]: #basic.type.qualifier
+[basic.type.qualifier.rel]: #basic.type.qualifier.rel
+[basic.types]: #basic.types
+[bit.cast]: numerics.md#bit.cast
+[c.malloc]: utilities.md#c.malloc
+[class]: class.md#class
+[class.abstract]: class.md#class.abstract
+[class.access]: class.md#class.access
+[class.base.init]: class.md#class.base.init
+[class.bit]: class.md#class.bit
+[class.cdtor]: class.md#class.cdtor
+[class.conv.fct]: class.md#class.conv.fct
+[class.copy.assign]: class.md#class.copy.assign
+[class.copy.ctor]: class.md#class.copy.ctor
+[class.copy.elision]: class.md#class.copy.elision
+[class.default.ctor]: class.md#class.default.ctor
+[class.derived]: class.md#class.derived
+[class.dtor]: class.md#class.dtor
+[class.free]: class.md#class.free
+[class.friend]: class.md#class.friend
+[class.local]: class.md#class.local
+[class.mem]: class.md#class.mem
+[class.member.lookup]: class.md#class.member.lookup
+[class.mfct]: class.md#class.mfct
+[class.mfct.non-static]: class.md#class.mfct.non-static
+[class.name]: class.md#class.name
+[class.nest]: class.md#class.nest
+[class.pre]: class.md#class.pre
+[class.prop]: class.md#class.prop
+[class.qual]: #class.qual
+[class.spaceship]: class.md#class.spaceship
+[class.static]: class.md#class.static
+[class.static.data]: class.md#class.static.data
+[class.temporary]: #class.temporary
+[class.this]: class.md#class.this
+[class.union]: class.md#class.union
+[class.virtual]: class.md#class.virtual
+[conv]: expr.md#conv
+[conv.array]: expr.md#conv.array
+[conv.func]: expr.md#conv.func
+[conv.integral]: expr.md#conv.integral
+[conv.lval]: expr.md#conv.lval
+[conv.mem]: expr.md#conv.mem
+[conv.prom]: expr.md#conv.prom
+[conv.ptr]: expr.md#conv.ptr
+[conv.rank]: #conv.rank
+[conv.rval]: expr.md#conv.rval
+[cpp.predefined]: cpp.md#cpp.predefined
+[cstddef.syn]: support.md#cstddef.syn
+[cstring.syn]: strings.md#cstring.syn
+[dcl.align]: dcl.md#dcl.align
+[dcl.array]: dcl.md#dcl.array
+[dcl.attr]: dcl.md#dcl.attr
+[dcl.attr.nouniqueaddr]: dcl.md#dcl.attr.nouniqueaddr
+[dcl.constexpr]: dcl.md#dcl.constexpr
+[dcl.dcl]: dcl.md#dcl.dcl
+[dcl.decl]: dcl.md#dcl.decl
+[dcl.enum]: dcl.md#dcl.enum
+[dcl.fct]: dcl.md#dcl.fct
+[dcl.fct.def]: dcl.md#dcl.fct.def
+[dcl.fct.def.coroutine]: dcl.md#dcl.fct.def.coroutine
+[dcl.fct.def.general]: dcl.md#dcl.fct.def.general
+[dcl.fct.default]: dcl.md#dcl.fct.default
+[dcl.init]: dcl.md#dcl.init
+[dcl.init.aggr]: dcl.md#dcl.init.aggr
+[dcl.init.list]: dcl.md#dcl.init.list
+[dcl.init.ref]: dcl.md#dcl.init.ref
+[dcl.inline]: dcl.md#dcl.inline
+[dcl.link]: dcl.md#dcl.link
+[dcl.meaning]: dcl.md#dcl.meaning
+[dcl.mptr]: dcl.md#dcl.mptr
+[dcl.name]: dcl.md#dcl.name
+[dcl.pre]: dcl.md#dcl.pre
+[dcl.ptr]: dcl.md#dcl.ptr
+[dcl.ref]: dcl.md#dcl.ref
+[dcl.spec]: dcl.md#dcl.spec
+[dcl.spec.auto]: dcl.md#dcl.spec.auto
+[dcl.stc]: dcl.md#dcl.stc
+[dcl.struct.bind]: dcl.md#dcl.struct.bind
+[dcl.type.elab]: dcl.md#dcl.type.elab
+[dcl.typedef]: dcl.md#dcl.typedef
+[defns.block]: intro.md#defns.block
+[defns.signature]: intro.md#defns.signature
+[defns.signature.templ]: intro.md#defns.signature.templ
+[depr.local]: future.md#depr.local
+[depr.static.constexpr]: future.md#depr.static.constexpr
+[diff.cpp11.basic]: compatibility.md#diff.cpp11.basic
+[enum.udecl]: dcl.md#enum.udecl
+[except.handle]: except.md#except.handle
+[except.pre]: except.md#except.pre
+[except.spec]: except.md#except.spec
+[except.terminate]: except.md#except.terminate
+[except.throw]: except.md#except.throw
+[expr]: expr.md#expr
+[expr.add]: expr.md#expr.add
+[expr.alignof]: expr.md#expr.alignof
+[expr.arith.conv]: expr.md#expr.arith.conv
+[expr.ass]: expr.md#expr.ass
+[expr.await]: expr.md#expr.await
+[expr.call]: expr.md#expr.call
+[expr.cast]: expr.md#expr.cast
+[expr.comma]: expr.md#expr.comma
+[expr.compound]: expr.md#expr.compound
+[expr.cond]: expr.md#expr.cond
+[expr.const]: expr.md#expr.const
+[expr.const.cast]: expr.md#expr.const.cast
+[expr.context]: expr.md#expr.context
+[expr.delete]: expr.md#expr.delete
+[expr.dynamic.cast]: expr.md#expr.dynamic.cast
+[expr.eq]: expr.md#expr.eq
+[expr.log.and]: expr.md#expr.log.and
+[expr.log.or]: expr.md#expr.log.or
+[expr.mptr.oper]: expr.md#expr.mptr.oper
+[expr.new]: expr.md#expr.new
+[expr.pre]: expr.md#expr.pre
+[expr.prim.id]: expr.md#expr.prim.id
+[expr.prim.id.dtor]: expr.md#expr.prim.id.dtor
+[expr.prim.id.qual]: expr.md#expr.prim.id.qual
+[expr.prim.lambda]: expr.md#expr.prim.lambda
+[expr.prim.lambda.capture]: expr.md#expr.prim.lambda.capture
+[expr.prim.lambda.closure]: expr.md#expr.prim.lambda.closure
+[expr.prim.this]: expr.md#expr.prim.this
+[expr.prop]: expr.md#expr.prop
+[expr.ref]: expr.md#expr.ref
+[expr.reinterpret.cast]: expr.md#expr.reinterpret.cast
+[expr.rel]: expr.md#expr.rel
+[expr.sizeof]: expr.md#expr.sizeof
+[expr.static.cast]: expr.md#expr.static.cast
+[expr.sub]: expr.md#expr.sub
+[expr.type.conv]: expr.md#expr.type.conv
+[expr.typeid]: expr.md#expr.typeid
+[expr.unary.op]: expr.md#expr.unary.op
+[get.new.handler]: support.md#get.new.handler
+[headers]: library.md#headers
+[intro.execution]: #intro.execution
+[intro.memory]: #intro.memory
+[intro.multithread]: #intro.multithread
+[intro.object]: #intro.object
+[intro.progress]: #intro.progress
+[intro.races]: #intro.races
+[lex.charset]: lex.md#lex.charset
+[lex.name]: lex.md#lex.name
+[lex.separate]: lex.md#lex.separate
+[locale]: localization.md#locale
+[meta.trans.other]: utilities.md#meta.trans.other
+[module.context]: module.md#module.context
+[module.global.frag]: module.md#module.global.frag
+[module.import]: module.md#module.import
+[module.interface]: module.md#module.interface
+[module.reach]: module.md#module.reach
+[module.unit]: module.md#module.unit
+[multibyte.strings]: library.md#multibyte.strings
+[namespace.def]: dcl.md#namespace.def
+[namespace.memdef]: dcl.md#namespace.memdef
+[namespace.qual]: #namespace.qual
+[namespace.udecl]: dcl.md#namespace.udecl
+[namespace.udir]: dcl.md#namespace.udir
+[new.delete]: support.md#new.delete
+[new.delete.array]: support.md#new.delete.array
+[new.delete.placement]: support.md#new.delete.placement
+[new.delete.single]: support.md#new.delete.single
+[new.handler]: support.md#new.handler
+[over]: over.md#over
+[over.literal]: over.md#over.literal
+[over.match]: over.md#over.match
+[over.oper]: over.md#over.oper
+[over.over]: over.md#over.over
+[ptr.align]: utilities.md#ptr.align
+[ptr.launder]: support.md#ptr.launder
+[replacement.functions]: library.md#replacement.functions
+[special]: class.md#special
+[stmt.block]: stmt.md#stmt.block
+[stmt.dcl]: stmt.md#stmt.dcl
+[stmt.expr]: stmt.md#stmt.expr
+[stmt.goto]: stmt.md#stmt.goto
+[stmt.if]: stmt.md#stmt.if
+[stmt.label]: stmt.md#stmt.label
+[stmt.ranged]: stmt.md#stmt.ranged
+[stmt.return]: stmt.md#stmt.return
+[support.dynamic]: support.md#support.dynamic
+[support.limits]: support.md#support.limits
+[support.runtime]: support.md#support.runtime
+[support.start.term]: support.md#support.start.term
+[support.types]: support.md#support.types
+[temp.deduct.guide]: temp.md#temp.deduct.guide
+[temp.dep]: temp.md#temp.dep
+[temp.dep.candidate]: temp.md#temp.dep.candidate
+[temp.expl.spec]: temp.md#temp.expl.spec
+[temp.explicit]: temp.md#temp.explicit
+[temp.local]: temp.md#temp.local
+[temp.names]: temp.md#temp.names
+[temp.nondep]: temp.md#temp.nondep
+[temp.over]: temp.md#temp.over
+[temp.param]: temp.md#temp.param
+[temp.point]: temp.md#temp.point
+[temp.pre]: temp.md#temp.pre
+[temp.res]: temp.md#temp.res
+[temp.spec]: temp.md#temp.spec
+[temp.type]: temp.md#temp.type
+[thread]: thread.md#thread
+[thread.jthread.class]: thread.md#thread.jthread.class
+[thread.thread.class]: thread.md#thread.thread.class
+[thread.threads]: thread.md#thread.threads
+[util.dynamic.safety]: utilities.md#util.dynamic.safety
+[^1]: Appearing inside the brace-enclosed *declaration-seq* in a
+    *linkage-specification* does not affect whether a declaration is a
+    definition.
+[^2]: An implementation is not required to call allocation and
+    deallocation functions from constructors or destructors; however,
+    this is a permissible implementation technique.
+[^3]: This refers to unqualified names that occur, for instance, in a
+    type or default argument in the *parameter-declaration-clause* or
+    used in the function body.
+[^4]: This refers to unqualified names following the class name; such a
+    name may be used in a *base-specifier* or in the
+    *member-specification* of the class definition.
+[^5]: This lookup applies whether the definition of `X` is nested within
+    `Y`’s definition or whether `X`’s definition appears in a namespace
+    scope enclosing `Y`’s definition [[class.nest]].
+[^6]: That is, an unqualified name that occurs, for instance, in a type
+    in the *parameter-declaration-clause* or in the
+    *noexcept-specifier*.
+[^7]: This lookup applies whether the member function is defined within
+    the definition of class `X` or whether the member function is
+    defined in a namespace scope enclosing `X`’s definition.
+[^8]: Lookups in which function names are ignored include names
+    appearing in a *nested-name-specifier*, an
+    *elaborated-type-specifier*, or a *base-specifier*.
+[^9]: The number of bits in a byte is reported by the macro `CHAR_BIT`
+    in the header `<climits>`.
+[^10]: Under the “as-if” rule an implementation is allowed to store two
+    objects at the same machine address or not store an object at all if
+    the program cannot observe the difference [[intro.execution]].
+[^11]: For example, before the construction of a global object that is
+    initialized via a user-provided constructor [[class.cdtor]].
+[^12]: That is, an object for which a destructor will be called
+    implicitly—upon exit from the block for an object with automatic
+    storage duration, upon exit from the thread for an object with
+    thread storage duration, or upon exit from the program for an object
+    with static storage duration.
+[^13]: Some implementations might define that copying an invalid pointer
+    value causes a system-generated runtime fault.
+[^14]: The intent is to have `operator new()` implementable by calling
+    `std::malloc()` or `std::calloc()`, so the rules are substantially
+    the same. C++ differs from C in requiring a zero request to return a
+    non-null pointer.
+[^15]: The global `operator delete(void*, std::size_t)` precludes use of
+    an allocation function `void operator new(std::size_t, std::size_t)`
+    as a placement allocation function ([[diff.cpp11.basic]]).
+[^16]: This subclause does not impose restrictions on indirection
+    through pointers to memory not allocated by `::operator new`. This
+    maintains the ability of many C++ implementations to use binary
+    libraries and components written in other languages. In particular,
+    this applies to C binaries, because indirection through pointers to
+    memory allocated by `std::malloc` is not restricted.
+[^17]: The same rules apply to initialization of an `initializer_list`
+    object [[dcl.init.list]] with its underlying temporary array.
+[^18]: By using, for example, the library functions [[headers]]
+    `std::memcpy` or `std::memmove`.
+[^19]: By using, for example, the library functions [[headers]]
+    `std::memcpy` or `std::memmove`.
+[^20]: The intent is that the memory model of C++ is compatible with
+    that of ISO/IEC 9899 Programming Language C.
+[^21]: The size and layout of an instance of an incompletely-defined
+    object type is unknown.
+[^22]: This is also known as two’s complement representation.
+[^23]: Static class members are objects or functions, and pointers to
+    them are ordinary pointers to objects or functions.
+[^24]: For an object that is not within its lifetime, this is the first
+    byte in memory that it will occupy or used to occupy.
+[^25]: The same representation and alignment requirements are meant to
+    imply interchangeability as arguments to functions, return values
+    from functions, and non-static data members of unions.
+[^26]: As specified in  [[class.temporary]], after a full-expression is
+    evaluated, a sequence of zero or more invocations of destructor
+    functions for temporary objects takes place, usually in reverse
+    order of the construction of each temporary object.
+[^27]: In other words, function executions do not interleave with each
+    other.
+[^28]: An object with automatic or thread storage duration [[basic.stc]]
+    is associated with one specific thread, and can be accessed by a
+    different thread only indirectly through a pointer or reference
+    [[basic.compound]].
+[^29]: A non-local variable with static storage duration having
+    initialization with side effects is initialized in this case, even
+    if it is not itself odr-used ([[basic.def.odr]],
+    [[basic.stc.static]]).

Diff to HTML by rtfpessoa