[basic.stc] - C++20 → C++23

Files changed (1) hide show

tmp/tmp3tiaebah/{from.md → to.md} +58 -116

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

@@ -1,7 +1,9 @@
 ### Storage duration <a id="basic.stc">[[basic.stc]]</a>
 The *storage duration* is the property of an object that defines the
 minimum potential lifetime of the storage containing the object. The
 storage duration is determined by the construct used to create the
 object and is one of the following:
@@ -21,33 +23,35 @@ When the end of the duration of a region of storage is reached, the
 values of all pointers representing the address of any part of that
 region of storage become invalid pointer values [[basic.compound]].
 Indirection through an invalid pointer value and passing an invalid
 pointer value to a deallocation function have undefined behavior. Any
 other use of an invalid pointer value has *implementation-defined*
-behavior.[^13]
 #### Static storage duration <a id="basic.stc.static">[[basic.stc.static]]</a>
-All variables which do not have dynamic storage duration, do not have
-thread storage duration, and are not local have *static storage
-duration*. The storage for these entities lasts for the duration of the
-program ([[basic.start.static]], [[basic.start.term]]).
 If a variable with static storage duration has initialization or a
 destructor with side effects, it shall not be eliminated even if it
 appears to be unused, except that a class object or its copy/move may be
 eliminated as specified in  [[class.copy.elision]].
-The keyword `static` can be used to declare a local variable with static
-storage duration.
-[*Note 1*:  [[stmt.dcl]] describes the initialization of local `static`
-variables; [[basic.start.term]] describes the destruction of local
-`static` variables. — *end note*]
-The keyword `static` applied to a class data member in a class
-definition gives the data member static storage duration.
 #### Thread storage duration <a id="basic.stc.thread">[[basic.stc.thread]]</a>
 All variables declared with the `thread_local` keyword have
 *thread storage duration*. The storage for these entities lasts for the
@@ -60,13 +64,14 @@ specified in  [[basic.start.static]], [[basic.start.dynamic]], and
 [[stmt.dcl]] and, if constructed, is destroyed on thread exit
 [[basic.start.term]]. — *end note*]
 #### Automatic storage duration <a id="basic.stc.auto">[[basic.stc.auto]]</a>
-Block-scope variables not explicitly declared `static`, `thread_local`,
-or `extern` have *automatic storage duration*. The storage for these
-entities lasts until the block in which they are created exits.
 [*Note 1*: These variables are initialized and destroyed as described
 in  [[stmt.dcl]]. — *end note*]
 If a variable with automatic storage duration has initialization or a
@@ -75,30 +80,33 @@ before the end of its block nor eliminate it as an optimization, even if
 it appears to be unused, except that a class object or its copy/move may
 be eliminated as specified in  [[class.copy.elision]].
 #### Dynamic storage duration <a id="basic.stc.dynamic">[[basic.stc.dynamic]]</a>
 Objects can be created dynamically during program execution
 [[intro.execution]], using *new-expression*s [[expr.new]], and destroyed
 using *delete-expression*s [[expr.delete]]. A C++ implementation
 provides access to, and management of, dynamic storage via the global
-*allocation functions* `operator new` and `operator
-new[]` and the global *deallocation functions* `operator
-delete` and `operator delete[]`.
 [*Note 1*: The non-allocating forms described in
 [[new.delete.placement]] do not perform allocation or
 deallocation. — *end note*]
 The library provides default definitions for the global allocation and
 deallocation functions. Some global allocation and deallocation
-functions are replaceable [[new.delete]]. A C++ program shall provide at
-most one definition of a replaceable allocation or deallocation
-function. Any such function definition replaces the default version
-provided in the library [[replacement.functions]]. The following
-allocation and deallocation functions [[support.dynamic]] are implicitly
-declared in global scope in each translation unit of a program.
 ``` cpp
 [[nodiscard]] void* operator new(std::size_t);
 [[nodiscard]] void* operator new(std::size_t, std::align_val_t);
@@ -114,22 +122,24 @@ void operator delete[](void*) noexcept;
 void operator delete[](void*, std::size_t) noexcept;
 void operator delete[](void*, std::align_val_t) noexcept;
 void operator delete[](void*, std::size_t, std::align_val_t) noexcept;
 ```
-These implicit declarations introduce only the function names `operator`
-`new`, `operator` `new[]`, `operator` `delete`, and `operator`
-`delete[]`.
 [*Note 2*: The implicit declarations do not introduce the names `std`,
 `std::size_t`, `std::align_val_t`, or any other names that the library
 uses to declare these names. Thus, a *new-expression*,
 *delete-expression*, or function call that refers to one of these
-functions without importing or including the header `<new>` is
-well-formed. However, referring to `std` or `std::size_t` or
-`std::align_val_t` is ill-formed unless the name has been declared by
-importing or including the appropriate header. — *end note*]
 Allocation and/or deallocation functions may also be declared and
 defined for any class [[class.free]].
 If the behavior of an allocation or deallocation function does not
@@ -137,22 +147,21 @@ satisfy the semantic constraints specified in
 [[basic.stc.dynamic.allocation]] and
 [[basic.stc.dynamic.deallocation]], the behavior is undefined.
 ##### Allocation functions <a id="basic.stc.dynamic.allocation">[[basic.stc.dynamic.allocation]]</a>
-An allocation function shall be a class member function or a global
-function; a program is ill-formed if an allocation function is declared
-in a namespace scope other than global scope or declared static in
-global scope. The return type shall be `void*`. The first parameter
-shall have type `std::size_t` [[support.types]]. The first parameter
-shall not have an associated default argument [[dcl.fct.default]]. The
-value of the first parameter is interpreted as the requested size of the
-allocation. An allocation function can be a function template. Such a
-template shall declare its return type and first parameter as specified
-above (that is, template parameter types shall not be used in the return
-type and first parameter type). Template allocation functions shall have
-two or more parameters.
 An allocation function attempts to allocate the requested amount of
 storage. If it is successful, it returns the address of the start of a
 block of storage whose length in bytes is at least as large as the
 requested size. The order, contiguity, and initial value of storage
@@ -164,11 +173,11 @@ from any previously returned value `p1`, unless that value `p1` was
 subsequently passed to a replaceable deallocation function. Furthermore,
 for the library allocation functions in  [[new.delete.single]] and
 [[new.delete.array]], `p0` represents the address of a block of storage
 disjoint from the storage for any other object accessible to the caller.
 The effect of indirecting through a pointer returned from a request for
-zero size is undefined.[^14]
 For an allocation function other than a reserved placement allocation
 function [[new.delete.placement]], the pointer returned on a successful
 call shall represent the address of storage that is aligned as follows:
@@ -208,14 +217,12 @@ duration [[basic.stc.thread]], for objects of type `std::type_info`
 [[expr.typeid]], or for an exception object
 [[except.throw]]. — *end note*]
 ##### Deallocation functions <a id="basic.stc.dynamic.deallocation">[[basic.stc.dynamic.deallocation]]</a>
-Deallocation functions shall be class member functions or global
-functions; a program is ill-formed if deallocation functions are
-declared in a namespace scope other than global scope or declared static
-in global scope.
 A deallocation function is a *destroying operator delete* if it has at
 least two parameters and its second parameter is of type
 `std::destroying_delete_t`. A destroying operator delete shall be a
 class member function named `operator delete`.
@@ -229,11 +236,11 @@ first parameter shall be `C*`; otherwise, the type of its first
 parameter shall be `void*`. A deallocation function may have more than
 one parameter. A *usual deallocation function* is a deallocation
 function whose parameters after the first are
 - optionally, a parameter of type `std::destroying_delete_t`, then
-- optionally, a parameter of type `std::size_t` [^15], then
 - optionally, a parameter of type `std::align_val_t`.
 A destroying operator delete shall be a usual deallocation function. A
 deallocation function may be an instance of a function template. Neither
 the first parameter nor the return type shall depend on a template
@@ -250,75 +257,10 @@ has no effect.
 If the argument given to a deallocation function in the standard library
 is a pointer that is not the null pointer value [[basic.compound]], the
 deallocation function shall deallocate the storage referenced by the
 pointer, ending the duration of the region of storage.
-##### Safely-derived pointers <a id="basic.stc.dynamic.safety">[[basic.stc.dynamic.safety]]</a>
-A *traceable pointer object* is
-- an object of an object pointer type [[basic.compound]], or
-- an object of an integral type that is at least as large as
-  `std::intptr_t`, or
-- a sequence of elements in an array of narrow character type
-  [[basic.fundamental]], where the size and alignment of the sequence
-  match those of some object pointer type.
-A pointer value is a *safely-derived pointer* to an object with dynamic
-storage duration only if the pointer value has an object pointer type
-and is one of the following:
-- the value returned by a call to the C++ standard library
-  implementation of `::operator new(std::{}size_t)` or
-  `::operator new(std::size_t, std::align_val_t)` ;[^16]
-- the result of taking the address of an object (or one of its
-  subobjects) designated by an lvalue resulting from indirection through
-  a safely-derived pointer value;
-- the result of well-defined pointer arithmetic [[expr.add]] using a
-  safely-derived pointer value;
-- the result of a well-defined pointer conversion ([[conv.ptr]],
-  [[expr.type.conv]], [[expr.static.cast]], [[expr.cast]]) of a
-  safely-derived pointer value;
-- the result of a `reinterpret_cast` of a safely-derived pointer value;
-- the result of a `reinterpret_cast` of an integer representation of a
-  safely-derived pointer value;
-- the value of an object whose value was copied from a traceable pointer
-  object, where at the time of the copy the source object contained a
-  copy of a safely-derived pointer value.
-An integer value is an *integer representation of a safely-derived
-pointer* only if its type is at least as large as `std::intptr_t` and it
-is one of the following:
-- the result of a `reinterpret_cast` of a safely-derived pointer value;
-- the result of a valid conversion of an integer representation of a
-  safely-derived pointer value;
-- the value of an object whose value was copied from a traceable pointer
-  object, where at the time of the copy the source object contained an
-  integer representation of a safely-derived pointer value;
-- the result of an additive or bitwise operation, one of whose operands
-  is an integer representation of a safely-derived pointer value `P`, if
-  that result converted by `reinterpret_cast<void*>` would compare equal
-  to a safely-derived pointer computable from
-  `reinterpret_cast<void*>(P)`.
-An implementation may have *relaxed pointer safety*, in which case the
-validity of a pointer value does not depend on whether it is a
-safely-derived pointer value. Alternatively, an implementation may have
-*strict pointer safety*, in which case a pointer value referring to an
-object with dynamic storage duration that is not a safely-derived
-pointer value is an invalid pointer value unless the referenced complete
-object has previously been declared reachable [[util.dynamic.safety]].
-[*Note 6*: The effect of using an invalid pointer value (including
-passing it to a deallocation function) is undefined, see  [[basic.stc]].
-This is true even if the unsafely-derived pointer value might compare
-equal to some safely-derived pointer value. — *end note*]
-It is *implementation-defined* whether an implementation has relaxed or
-strict pointer safety.
 #### Duration of subobjects <a id="basic.stc.inherit">[[basic.stc.inherit]]</a>
 The storage duration of subobjects and reference members is that of
 their complete object [[intro.object]].

 ### Storage duration <a id="basic.stc">[[basic.stc]]</a>
+#### General <a id="basic.stc.general">[[basic.stc.general]]</a>
 The *storage duration* is the property of an object that defines the
 minimum potential lifetime of the storage containing the object. The
 storage duration is determined by the construct used to create the
 object and is one of the following:
 values of all pointers representing the address of any part of that
 region of storage become invalid pointer values [[basic.compound]].
 Indirection through an invalid pointer value and passing an invalid
 pointer value to a deallocation function have undefined behavior. Any
 other use of an invalid pointer value has *implementation-defined*
+behavior.[^10]
 #### Static storage duration <a id="basic.stc.static">[[basic.stc.static]]</a>
+All variables which
+- do not have thread storage duration and
+- belong to a namespace scope [[basic.scope.namespace]] or are first
+  declared with the `static` or `extern` keywords [[dcl.stc]]
+have *static storage duration*. The storage for these entities lasts for
+the duration of the program
+[[basic.start.static]], [[basic.start.term]].
 If a variable with static storage duration has initialization or a
 destructor with side effects, it shall not be eliminated even if it
 appears to be unused, except that a class object or its copy/move may be
 eliminated as specified in  [[class.copy.elision]].
+[*Note 1*:  The keyword `static` can be used to declare a block
+variable [[basic.scope.block]] with static storage duration;
+[[stmt.dcl]] and [[basic.start.term]] describe the initialization and
+destruction of such variables. The keyword `static` applied to a class
+data member in a class definition gives the data member static storage
+duration [[class.static.data]]. — *end note*]
 #### Thread storage duration <a id="basic.stc.thread">[[basic.stc.thread]]</a>
 All variables declared with the `thread_local` keyword have
 *thread storage duration*. The storage for these entities lasts for the
 [[stmt.dcl]] and, if constructed, is destroyed on thread exit
 [[basic.start.term]]. — *end note*]
 #### Automatic storage duration <a id="basic.stc.auto">[[basic.stc.auto]]</a>
+Variables that belong to a block or parameter scope and are not
+explicitly declared `static`, `thread_local`, or `extern` have
+*automatic storage duration*. The storage for these entities lasts until
+the block in which they are created exits.
 [*Note 1*: These variables are initialized and destroyed as described
 in  [[stmt.dcl]]. — *end note*]
 If a variable with automatic storage duration has initialization or a
 it appears to be unused, except that a class object or its copy/move may
 be eliminated as specified in  [[class.copy.elision]].
 #### Dynamic storage duration <a id="basic.stc.dynamic">[[basic.stc.dynamic]]</a>
+##### General <a id="basic.stc.dynamic.general">[[basic.stc.dynamic.general]]</a>
 Objects can be created dynamically during program execution
 [[intro.execution]], using *new-expression*s [[expr.new]], and destroyed
 using *delete-expression*s [[expr.delete]]. A C++ implementation
 provides access to, and management of, dynamic storage via the global
+*allocation functions* `operator new` and `operator new[]` and the
+global *deallocation functions* `operator delete` and
+`operator delete[]`.
 [*Note 1*: The non-allocating forms described in
 [[new.delete.placement]] do not perform allocation or
 deallocation. — *end note*]
 The library provides default definitions for the global allocation and
 deallocation functions. Some global allocation and deallocation
+functions are replaceable [[new.delete]]; these are attached to the
+global module [[module.unit]]. A C++ program shall provide at most one
+definition of a replaceable allocation or deallocation function. Any
+such function definition replaces the default version provided in the
+library [[replacement.functions]]. The following allocation and
+deallocation functions [[support.dynamic]] are implicitly declared in
+global scope in each translation unit of a program.
 ``` cpp
 [[nodiscard]] void* operator new(std::size_t);
 [[nodiscard]] void* operator new(std::size_t, std::align_val_t);
 void operator delete[](void*, std::size_t) noexcept;
 void operator delete[](void*, std::align_val_t) noexcept;
 void operator delete[](void*, std::size_t, std::align_val_t) noexcept;
 ```
+These implicit declarations introduce only the function names
+`operator new`, `operator new[]`, `operator delete`, and
+`operator delete[]`.
 [*Note 2*: The implicit declarations do not introduce the names `std`,
 `std::size_t`, `std::align_val_t`, or any other names that the library
 uses to declare these names. Thus, a *new-expression*,
 *delete-expression*, or function call that refers to one of these
+functions without importing or including the header `<new>` or importing
+a C++ library module [[std.modules]] is well-formed. However, referring
+to `std` or `std::size_t` or `std::align_val_t` is ill-formed unless a
+standard library declaration
+[[cstddef.syn]], [[new.syn]], [[std.modules]] of that name precedes
+[[basic.lookup.general]] the use of that name. — *end note*]
 Allocation and/or deallocation functions may also be declared and
 defined for any class [[class.free]].
 If the behavior of an allocation or deallocation function does not
 [[basic.stc.dynamic.allocation]] and
 [[basic.stc.dynamic.deallocation]], the behavior is undefined.
 ##### Allocation functions <a id="basic.stc.dynamic.allocation">[[basic.stc.dynamic.allocation]]</a>
+An allocation function that is not a class member function shall belong
+to the global scope and not have a name with internal linkage. The
+return type shall be `void*`. The first parameter shall have type
+`std::size_t` [[support.types]]. The first parameter shall not have an
+associated default argument [[dcl.fct.default]]. The value of the first
+parameter is interpreted as the requested size of the allocation. An
+allocation function can be a function template. Such a template shall
+declare its return type and first parameter as specified above (that is,
+template parameter types shall not be used in the return type and first
+parameter type). Allocation function templates shall have two or more
+parameters.
 An allocation function attempts to allocate the requested amount of
 storage. If it is successful, it returns the address of the start of a
 block of storage whose length in bytes is at least as large as the
 requested size. The order, contiguity, and initial value of storage
 subsequently passed to a replaceable deallocation function. Furthermore,
 for the library allocation functions in  [[new.delete.single]] and
 [[new.delete.array]], `p0` represents the address of a block of storage
 disjoint from the storage for any other object accessible to the caller.
 The effect of indirecting through a pointer returned from a request for
+zero size is undefined.[^11]
 For an allocation function other than a reserved placement allocation
 function [[new.delete.placement]], the pointer returned on a successful
 call shall represent the address of storage that is aligned as follows:
 [[expr.typeid]], or for an exception object
 [[except.throw]]. — *end note*]
 ##### Deallocation functions <a id="basic.stc.dynamic.deallocation">[[basic.stc.dynamic.deallocation]]</a>
+A deallocation function that is not a class member function shall belong
+to the global scope and not have a name with internal linkage.
 A deallocation function is a *destroying operator delete* if it has at
 least two parameters and its second parameter is of type
 `std::destroying_delete_t`. A destroying operator delete shall be a
 class member function named `operator delete`.
 parameter shall be `void*`. A deallocation function may have more than
 one parameter. A *usual deallocation function* is a deallocation
 function whose parameters after the first are
 - optionally, a parameter of type `std::destroying_delete_t`, then
+- optionally, a parameter of type `std::size_t`,[^12] then
 - optionally, a parameter of type `std::align_val_t`.
 A destroying operator delete shall be a usual deallocation function. A
 deallocation function may be an instance of a function template. Neither
 the first parameter nor the return type shall depend on a template
 If the argument given to a deallocation function in the standard library
 is a pointer that is not the null pointer value [[basic.compound]], the
 deallocation function shall deallocate the storage referenced by the
 pointer, ending the duration of the region of storage.
 #### Duration of subobjects <a id="basic.stc.inherit">[[basic.stc.inherit]]</a>
 The storage duration of subobjects and reference members is that of
 their complete object [[intro.object]].

Diff to HTML by rtfpessoa