[basic.stc] - C++14 → C++17

Files changed (1) hide show

tmp/tmpcpnzjt29/{from.md → to.md} +127 -107

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

@@ -1,42 +1,51 @@
 ## Storage duration <a id="basic.stc">[[basic.stc]]</a>
-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:
 - static storage duration
 - thread storage duration
 - automatic storage duration
 - dynamic storage duration
 Static, thread, and automatic storage durations are associated with
 objects introduced by declarations ([[basic.def]]) and implicitly
 created by the implementation ([[class.temporary]]). The dynamic
-storage duration is associated with objects created with `operator`
-`new` ([[expr.new]]).
-The storage duration categories apply to references as well. The
-lifetime of a reference is its storage duration.
 ### 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 shall last for the duration of
-the program ([[basic.start.init]], [[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]].
 The keyword `static` can be used to declare a local variable with static
-storage duration. [[stmt.dcl]] describes the initialization of local
-`static` variables; [[basic.start.term]] describes the destruction of
-local `static` variables.
 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>
@@ -51,23 +60,22 @@ A variable with thread storage duration shall be initialized before its
 first odr-use ([[basic.def.odr]]) and, if constructed, shall be
 destroyed on thread exit.
 ### Automatic storage duration <a id="basic.stc.auto">[[basic.stc.auto]]</a>
-Block-scope variables explicitly declared `register` or not explicitly
-declared `static` or `extern` have *automatic storage duration*. The
-storage for these entities lasts until the block in which they are
-created exits.
-These variables are initialized and destroyed as described in
-[[stmt.dcl]].
 If a variable with automatic storage duration has initialization or a
-destructor with side effects, it shall not be destroyed before the end
-of its block, nor shall it be eliminated 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]].
 ### 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
@@ -75,10 +83,14 @@ 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[]`.
 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
@@ -87,27 +99,41 @@ allocation and deallocation functions ([[support.dynamic]]) are
 implicitly declared in global scope in each translation unit of a
 program.
 ``` cpp
 void* operator new(std::size_t);
-void* operator new[](std::size_t);
 void operator delete(void*) noexcept;
-void operator delete[](void*) noexcept;
 void operator delete(void*, std::size_t) noexcept;
 void operator delete[](void*, std::size_t) noexcept;
 ```
 These implicit declarations introduce only the function names `operator`
 `new`, `operator` `new[]`, `operator` `delete`, and `operator`
-`delete[]`. The implicit declarations do not introduce the names `std`,
-`std::size_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 including the header
-`<new>` is well-formed. However, referring to `std` or `std::size_t` is
-ill-formed unless the name has been declared by including the
-appropriate header. Allocation and/or deallocation functions can also be
-declared and defined for any class ([[class.free]]).
 Any allocation and/or deallocation functions defined in a C++program,
 including the default versions in the library, shall conform to the
 semantics specified in  [[basic.stc.dynamic.allocation]] and
 [[basic.stc.dynamic.deallocation]].
@@ -132,102 +158,91 @@ storage. If it is successful, it shall return the address of the start
 of a block of storage whose length in bytes shall be at least as large
 as the requested size. There are no constraints on the contents of the
 allocated storage on return from the allocation function. The order,
 contiguity, and initial value of storage allocated by successive calls
 to an allocation function are unspecified. The pointer returned shall be
-suitably aligned so that it can be converted to a pointer of any
-complete object type with a fundamental alignment requirement (
-[[basic.align]]) and then used to access the object or array in the
-storage allocated (until the storage is explicitly deallocated by a call
-to a corresponding deallocation function). Even if the size of the space
-requested is zero, the request can fail. If the request succeeds, the
-value returned shall be a non-null pointer value ([[conv.ptr]]) `p0`
-different from any previously returned value `p1`, unless that value
-`p1` was subsequently passed to an `operator` `delete`. The effect of
-indirecting through a pointer returned as a request for zero size is
-undefined.[^12]
 An allocation function that fails to allocate storage can invoke the
-currently installed new-handler function ([[new.handler]]), if any. A
-program-supplied allocation function can obtain the address of the
-currently installed `new_handler` using the `std::get_new_handler`
-function ([[set.new.handler]]). If an allocation function declared with
-a non-throwing *exception-specification* ([[except.spec]]) fails to
-allocate storage, it shall return a null pointer. Any other allocation
-function that fails to allocate storage shall indicate failure only by
-throwing an exception ([[except.throw]]) of a type that would match a
-handler ([[except.handle]]) of type `std::bad_alloc` ([[bad.alloc]]).
 A global allocation function is only called as the result of a new
 expression ([[expr.new]]), or called directly using the function call
 syntax ([[expr.call]]), or called indirectly through calls to the
-functions in the C++standard library. In particular, a global allocation
-function is not called to allocate storage for objects with static
-storage duration ([[basic.stc.static]]), for objects or references with
-thread storage duration ([[basic.stc.thread]]), for objects of type
-`std::type_info` ([[expr.typeid]]), or for an exception object (
-[[except.throw]]).
 #### 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.
 Each deallocation function shall return `void` and its first parameter
-shall be `void*`. A deallocation function can have more than one
-parameter. The global `operator delete` with exactly one parameter is a
-usual (non-placement) deallocation function. The global
-`operator delete` with exactly two parameters, the second of which has
-type `std::size_t`, is a usual deallocation function. Similarly, the
-global `operator delete[]` with exactly one parameter is a usual
-deallocation function. The global `operator delete[]` with exactly two
-parameters, the second of which has type `std::size_t`, is a usual
-deallocation function.[^13] If a class `T` has a member deallocation
-function named `operator` `delete` with exactly one parameter, then that
-function is a usual deallocation function. If class `T` does not declare
-such an `operator` `delete` but does declare a member deallocation
-function named `operator` `delete` with exactly two parameters, the
-second of which has type `std::size_t`, then this function is a usual
-deallocation function. Similarly, if a class `T` has a member
-deallocation function named `operator` `delete[]` with exactly one
-parameter, then that function is a usual (non-placement) deallocation
-function. If class `T` does not declare such an `operator` `delete[]`
-but does declare a member deallocation function named `operator`
-`delete[]` with exactly two parameters, the second of which has type
-`std::size_t`, then this function is a usual deallocation function. A
-deallocation function can be an instance of a function template. Neither
-the first parameter nor the return type shall depend on a template
-parameter. That is, a deallocation function template shall have a first
 parameter of type `void*` and a return type of `void` (as specified
-above). A deallocation function template shall have two or more function
 parameters. A template instance is never a usual deallocation function,
 regardless of its signature.
 If a deallocation function terminates by throwing an exception, the
 behavior is undefined. The value of the first argument supplied to a
 deallocation function may be a null pointer value; if so, and if the
 deallocation function is one supplied in the standard library, the call
-has no effect. Otherwise, the behavior is undefined if the value
-supplied to `operator` `delete(void*)` in the standard library is not
-one of the values returned by a previous invocation of either `operator`
-`new(std::size_t)` or `operator` `new(std::size_t,` `const`
-`std::nothrow_t&)` in the standard library, and the behavior is
-undefined if the value supplied to `operator` `delete[](void*)` in the
-standard library is not one of the values returned by a previous
-invocation of either `operator` `new[](std::size_t)` or `operator`
-`new[](std::size_t,` `const` `std::nothrow_t&)` in the standard library.
 If the argument given to a deallocation function in the standard library
 is a pointer that is not the null pointer value ([[conv.ptr]]), the
 deallocation function shall deallocate the storage referenced by the
-pointer, rendering invalid all pointers referring to any part of the
-deallocated storage. 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.[^14]
 #### Safely-derived pointers <a id="basic.stc.dynamic.safety">[[basic.stc.dynamic.safety]]</a>
 A *traceable pointer object* is
@@ -240,11 +255,12 @@ A *traceable pointer object* is
 A pointer value is a *safely-derived pointer* to a dynamic object only
 if it has an object pointer type and it is one of the following:
 - the value returned by a call to the C++standard library implementation
-  of `::operator new(std::size_t)`;[^15]
 - 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;
@@ -255,13 +271,13 @@ if it has an object pointer type and it is one of the following:
   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
@@ -278,17 +294,21 @@ 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]]). the effect of using an invalid pointer value
-(including passing it to a deallocation function) is undefined, see
 [[basic.stc.dynamic.deallocation]]. This is true even if the
 unsafely-derived pointer value might compare equal to some
-safely-derived pointer value. 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 member subobjects, base class subobjects and
-array elements is that of their complete object ([[intro.object]]).

 ## 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:
 - static storage duration
 - thread storage duration
 - automatic storage duration
 - dynamic storage duration
 Static, thread, and automatic storage durations are associated with
 objects introduced by declarations ([[basic.def]]) and implicitly
 created by the implementation ([[class.temporary]]). The dynamic
+storage duration is associated with objects created by a
+*new-expression* ([[expr.new]]).
+The storage duration categories apply to references as well.
+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.[^12]
 ### 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 shall last 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]].
 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>
 first odr-use ([[basic.def.odr]]) and, if constructed, shall be
 destroyed on thread exit.
 ### 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
+destructor with side effects, an implementation shall not destroy it
+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]].
 ### 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
 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
 implicitly declared in global scope in each translation unit of a
 program.
 ``` cpp
 void* operator new(std::size_t);
+void* operator new(std::size_t, std::align_val_t);
 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;
+void* operator new[](std::size_t);
+void* operator new[](std::size_t, std::align_val_t);
+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 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 including the appropriate
+header. — *end note*]
+Allocation and/or deallocation functions may also be declared and
+defined for any class ([[class.free]]).
 Any allocation and/or deallocation functions defined in a C++program,
 including the default versions in the library, shall conform to the
 semantics specified in  [[basic.stc.dynamic.allocation]] and
 [[basic.stc.dynamic.deallocation]].
 of a block of storage whose length in bytes shall be at least as large
 as the requested size. There are no constraints on the contents of the
 allocated storage on return from the allocation function. The order,
 contiguity, and initial value of storage allocated by successive calls
 to an allocation function are unspecified. The pointer returned shall be
+suitably aligned so that it can be converted to a pointer to any
+suitable complete object type ([[new.delete.single]]) and then used to
+access the object or array in the storage allocated (until the storage
+is explicitly deallocated by a call to a corresponding deallocation
+function). Even if the size of the space requested is zero, the request
+can fail. If the request succeeds, the value returned shall be a
+non-null pointer value ([[conv.ptr]]) `p0` different from any
+previously returned value `p1`, unless that value `p1` was subsequently
+passed to an `operator` `delete`. Furthermore, for the library
+allocation functions in  [[new.delete.single]] and
+[[new.delete.array]], `p0` shall represent 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 as a
+request for zero size is undefined.[^13]
 An allocation function that fails to allocate storage can invoke the
+currently installed new-handler function ([[new.handler]]), if any.
+[*Note 1*:  A program-supplied allocation function can obtain the
+address of the currently installed `new_handler` using the
+`std::get_new_handler` function ([[set.new.handler]]). — *end note*]
+If an allocation function that has a non-throwing exception
+specification ([[except.spec]]) fails to allocate storage, it shall
+return a null pointer. Any other allocation function that fails to
+allocate storage shall indicate failure only by throwing an exception (
+[[except.throw]]) of a type that would match a handler (
+[[except.handle]]) of type `std::bad_alloc` ([[bad.alloc]]).
 A global allocation function is only called as the result of a new
 expression ([[expr.new]]), or called directly using the function call
 syntax ([[expr.call]]), or called indirectly through calls to the
+functions in the C++standard library.
+[*Note 2*: In particular, a global allocation function is not called to
+allocate storage for objects with static storage duration (
+[[basic.stc.static]]), for objects or references with thread storage
+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.
 Each deallocation function shall return `void` and its first parameter
+shall be `void*`. A deallocation function may have more than one
+parameter. A *usual deallocation function* is a deallocation function
+that has:
+- exactly one parameter; or
+- exactly two parameters, the type of the second being either
+  `std::align_val_t` or `std::size_t` [^14]; or
+- exactly three parameters, the type of the second being `std::size_t`
+  and the type of the third being `std::align_val_t`.
+A deallocation function may be an instance of a function template.
+Neither the first parameter nor the return type shall depend on a
+template parameter.
+[*Note 1*: That is, a deallocation function template shall have a first
 parameter of type `void*` and a return type of `void` (as specified
+above). — *end note*]
+A deallocation function template shall have two or more function
 parameters. A template instance is never a usual deallocation function,
 regardless of its signature.
 If a deallocation function terminates by throwing an exception, the
 behavior is undefined. The value of the first argument supplied to a
 deallocation function may be a null pointer value; if so, and if the
 deallocation function is one supplied in the standard library, the call
+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 ([[conv.ptr]]), 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
 A pointer value is a *safely-derived pointer* to a dynamic object only
 if it has an object pointer type and it 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)` ;[^15]
 - 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;
   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
 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 1*: The effect of using an invalid pointer value (including
+passing it to a deallocation function) is undefined, see
 [[basic.stc.dynamic.deallocation]]. 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]]).

Diff to HTML by rtfpessoa