[expr.new] - C++20 → C++23

Files changed (1) hide show

tmp/tmponnombgo/{from.md → to.md} +57 -59

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

@@ -1,17 +1,17 @@
 #### New <a id="expr.new">[[expr.new]]</a>
 The *new-expression* attempts to create an object of the *type-id*
 [[dcl.name]] or *new-type-id* to which it is applied. The type of that
 object is the *allocated type*. This type shall be a complete object
-type, but not an abstract class type or array thereof (
-[[intro.object]], [[basic.types]], [[class.abstract]]).
 [*Note 1*: Because references are not objects, references cannot be
 created by *new-expression*s. — *end note*]
-[*Note 2*: The *type-id* may be a cv-qualified type, in which case the
 object created by the *new-expression* has a cv-qualified
 type. — *end note*]
 ``` bnf
 new-expression:
@@ -117,27 +117,10 @@ returning `int`).
 — *end example*]
 — *end note*]
-Objects created by a *new-expression* have dynamic storage duration
-[[basic.stc.dynamic]].
-[*Note 5*:  The lifetime of such an object is not necessarily
-restricted to the scope in which it is created. — *end note*]
-When the allocated object is not an array, the result of the
-*new-expression* is a pointer to the object created.
-When the allocated object is an array (that is, the
-*noptr-new-declarator* syntax is used or the *new-type-id* or *type-id*
-denotes an array type), the *new-expression* yields a pointer to the
-initial element (if any) of the array.
-[*Note 6*: Both `new int` and `new int[10]` have type `int*` and the
-type of `new int[i][10]` is `int (*)[10]` — *end note*]
 The *attribute-specifier-seq* in a *noptr-new-declarator* appertains to
 the associated array type.
 Every *constant-expression* in a *noptr-new-declarator* shall be a
 converted constant expression [[expr.const]] of type `std::size_t` and
@@ -149,12 +132,12 @@ well-formed (because `n` is the *expression* of a
 `n` is not a constant expression). — *end example*]
 If the *type-id* or *new-type-id* denotes an array type of unknown bound
 [[dcl.array]], the *new-initializer* shall not be omitted; the allocated
 object is an array with `n` elements, where `n` is determined from the
-number of initial elements supplied in the *new-initializer* (
-[[dcl.init.aggr]], [[dcl.init.string]]).
 If the *expression* in a *noptr-new-declarator* is present, it is
 implicitly converted to `std::size_t`. The *expression* is erroneous if:
 - the expression is of non-class type and its value before converting to
@@ -169,12 +152,12 @@ implicitly converted to `std::size_t`. The *expression* is erroneous if:
   terminating `'\0'` in a *string-literal* [[lex.string]]) exceeds the
   number of elements to initialize.
 If the *expression* is erroneous after converting to `std::size_t`:
-- if the *expression* is a core constant expression, the program is
-  ill-formed;
 - otherwise, an allocation function is not called; instead
   - if the allocation function that would have been called has a
     non-throwing exception specification [[except.spec]], the value of
     the *new-expression* is the null pointer value of the required
     result type;
@@ -183,10 +166,26 @@ If the *expression* is erroneous after converting to `std::size_t`:
     `std::bad_array_new_length` [[new.badlength]].
 When the value of the *expression* is zero, the allocation function is
 called to allocate an array with no elements.
 A *new-expression* may obtain storage for the object by calling an
 allocation function [[basic.stc.dynamic.allocation]]. If the
 *new-expression* terminates by throwing an exception, it may release
 storage by calling a deallocation function
 [[basic.stc.dynamic.deallocation]]. If the allocated type is a non-array
@@ -194,28 +193,28 @@ type, the allocation function’s name is `operator new` and the
 deallocation function’s name is `operator delete`. If the allocated type
 is an array type, the allocation function’s name is `operator new[]` and
 the deallocation function’s name is `operator delete[]`.
 [*Note 7*: An implementation is required to provide default definitions
-for the global allocation functions ([[basic.stc.dynamic]],
-[[new.delete.single]], [[new.delete.array]]). A C++ program can provide
-alternative definitions of these functions [[replacement.functions]]
-and/or class-specific versions [[class.free]]. The set of allocation and
-deallocation functions that may be called by a *new-expression* may
-include functions that do not perform allocation or deallocation; for
-example, see [[new.delete.placement]]. — *end note*]
-If the *new-expression* begins with a unary `::` operator, the
-allocation function’s name is looked up in the global scope. Otherwise,
-if the allocated type is a class type `T` or array thereof, the
-allocation function’s name is looked up in the scope of `T`. If this
-lookup fails to find the name, or if the allocated type is not a class
-type, the allocation function’s name is looked up in the global scope.
 An implementation is allowed to omit a call to a replaceable global
-allocation function ([[new.delete.single]], [[new.delete.array]]). When
-it does so, the storage is instead provided by the implementation or
 provided by extending the allocation of another *new-expression*.
 During an evaluation of a constant expression, a call to an allocation
 function is always omitted.
@@ -346,12 +345,12 @@ from one invocation of `new` to another.
 — *end example*]
 [*Note 10*: Unless an allocation function has a non-throwing exception
 specification [[except.spec]], it indicates failure to allocate storage
-by throwing a `std::bad_alloc` exception (
-[[basic.stc.dynamic.allocation]], [[except]], [[bad.alloc]]); it returns
 a non-null pointer otherwise. If the allocation function has a
 non-throwing exception specification, it returns null to indicate
 failure to allocate storage and a non-null pointer
 otherwise. — *end note*]
@@ -382,34 +381,33 @@ evaluations of expressions in the *new-initializer*. Initialization of
 the allocated object is sequenced before the value computation of the
 *new-expression*.
 If the *new-expression* creates an object or an array of objects of
 class type, access and ambiguity control are done for the allocation
-function, the deallocation function [[class.free]], and the constructor
-[[class.ctor]] selected for the initialization (if any). If the
-*new-expression* creates an array of objects of class type, the
-destructor is potentially invoked [[class.dtor]].
-If any part of the object initialization described above[^24] terminates
-by throwing an exception and a suitable deallocation function can be
-found, the deallocation function is called to free the memory in which
-the object was being constructed, after which the exception continues to
-propagate in the context of the *new-expression*. If no unambiguous
-matching deallocation function can be found, propagating the exception
-does not cause the object’s memory to be freed.
 [*Note 13*: This is appropriate when the called allocation function
 does not allocate memory; otherwise, it is likely to result in a memory
 leak. — *end note*]
-If the *new-expression* begins with a unary `::` operator, the
-deallocation function’s name is looked up in the global scope.
-Otherwise, if the allocated type is a class type `T` or an array
-thereof, the deallocation function’s name is looked up in the scope of
-`T`. If this lookup fails to find the name, or if the allocated type is
-not a class type or array thereof, the deallocation function’s name is
-looked up in the global scope.
 A declaration of a placement deallocation function matches the
 declaration of a placement allocation function if it has the same number
 of parameters and, after parameter transformations [[dcl.fct]], all
 parameter types except the first are identical. If the lookup finds a

 #### New <a id="expr.new">[[expr.new]]</a>
 The *new-expression* attempts to create an object of the *type-id*
 [[dcl.name]] or *new-type-id* to which it is applied. The type of that
 object is the *allocated type*. This type shall be a complete object
+type [[term.incomplete.type]], but not an abstract class type
+[[class.abstract]] or array thereof [[intro.object]].
 [*Note 1*: Because references are not objects, references cannot be
 created by *new-expression*s. — *end note*]
+[*Note 2*: The *type-id* can be a cv-qualified type, in which case the
 object created by the *new-expression* has a cv-qualified
 type. — *end note*]
 ``` bnf
 new-expression:
 — *end example*]
 — *end note*]
 The *attribute-specifier-seq* in a *noptr-new-declarator* appertains to
 the associated array type.
 Every *constant-expression* in a *noptr-new-declarator* shall be a
 converted constant expression [[expr.const]] of type `std::size_t` and
 `n` is not a constant expression). — *end example*]
 If the *type-id* or *new-type-id* denotes an array type of unknown bound
 [[dcl.array]], the *new-initializer* shall not be omitted; the allocated
 object is an array with `n` elements, where `n` is determined from the
+number of initial elements supplied in the *new-initializer*
+[[dcl.init.aggr]], [[dcl.init.string]].
 If the *expression* in a *noptr-new-declarator* is present, it is
 implicitly converted to `std::size_t`. The *expression* is erroneous if:
 - the expression is of non-class type and its value before converting to
   terminating `'\0'` in a *string-literal* [[lex.string]]) exceeds the
   number of elements to initialize.
 If the *expression* is erroneous after converting to `std::size_t`:
+- if the *expression* is a potentially-evaluated core constant
+ expression, the program is ill-formed;
 - otherwise, an allocation function is not called; instead
   - if the allocation function that would have been called has a
     non-throwing exception specification [[except.spec]], the value of
     the *new-expression* is the null pointer value of the required
     result type;
     `std::bad_array_new_length` [[new.badlength]].
 When the value of the *expression* is zero, the allocation function is
 called to allocate an array with no elements.
+Objects created by a *new-expression* have dynamic storage duration
+[[basic.stc.dynamic]].
+[*Note 5*:  The lifetime of such an object is not necessarily
+restricted to the scope in which it is created. — *end note*]
+When the allocated type is “array of `N` `T`” (that is, the
+*noptr-new-declarator* syntax is used or the *new-type-id* or *type-id*
+denotes an array type), the *new-expression* yields a prvalue of type
+“pointer to `T`” that points to the initial element (if any) of the
+array. Otherwise, let `T` be the allocated type; the *new-expression* is
+a prvalue of type “pointer to T” that points to the object created.
+[*Note 6*: Both `new int` and `new int[10]` have type `int*` and the
+type of `new int[i][10]` is `int (*)[10]`. — *end note*]
 A *new-expression* may obtain storage for the object by calling an
 allocation function [[basic.stc.dynamic.allocation]]. If the
 *new-expression* terminates by throwing an exception, it may release
 storage by calling a deallocation function
 [[basic.stc.dynamic.deallocation]]. If the allocated type is a non-array
 deallocation function’s name is `operator delete`. If the allocated type
 is an array type, the allocation function’s name is `operator new[]` and
 the deallocation function’s name is `operator delete[]`.
 [*Note 7*: An implementation is required to provide default definitions
+for the global allocation functions
+[[basic.stc.dynamic]], [[new.delete.single]], [[new.delete.array]]. A
+C++ program can provide alternative definitions of these functions
+[[replacement.functions]] and/or class-specific versions [[class.free]].
+The set of allocation and deallocation functions that can be called by a
+*new-expression* can include functions that do not perform allocation or
+deallocation; for example, see [[new.delete.placement]]. — *end note*]
+If the *new-expression* does not begin with a unary `::` operator and
+the allocated type is a class type `T` or array thereof, a search is
+performed for the allocation function’s name in the scope of `T`
+[[class.member.lookup]]. Otherwise, or if nothing is found, the
+allocation function’s name is looked up by searching for it in the
+global scope.
 An implementation is allowed to omit a call to a replaceable global
+allocation function [[new.delete.single]], [[new.delete.array]]. When it
+does so, the storage is instead provided by the implementation or
 provided by extending the allocation of another *new-expression*.
 During an evaluation of a constant expression, a call to an allocation
 function is always omitted.
 — *end example*]
 [*Note 10*: Unless an allocation function has a non-throwing exception
 specification [[except.spec]], it indicates failure to allocate storage
+by throwing a `std::bad_alloc` exception
+[[basic.stc.dynamic.allocation]], [[except]], [[bad.alloc]]; it returns
 a non-null pointer otherwise. If the allocation function has a
 non-throwing exception specification, it returns null to indicate
 failure to allocate storage and a non-null pointer
 otherwise. — *end note*]
 the allocated object is sequenced before the value computation of the
 *new-expression*.
 If the *new-expression* creates an object or an array of objects of
 class type, access and ambiguity control are done for the allocation
+function, the deallocation function [[basic.stc.dynamic.deallocation]],
+and the constructor [[class.ctor]] selected for the initialization (if
+any). If the *new-expression* creates an array of objects of class type,
+the destructor is potentially invoked [[class.dtor]].
+If any part of the object initialization described above[^24]
+terminates by throwing an exception and a suitable deallocation function
+can be found, the deallocation function is called to free the memory in
+which the object was being constructed, after which the exception
+continues to propagate in the context of the *new-expression*. If no
+unambiguous matching deallocation function can be found, propagating the
+exception does not cause the object’s memory to be freed.
 [*Note 13*: This is appropriate when the called allocation function
 does not allocate memory; otherwise, it is likely to result in a memory
 leak. — *end note*]
+If the *new-expression* does not begin with a unary `::` operator and
+the allocated type is a class type `T` or an array thereof, a search is
+performed for the deallocation function’s name in the scope of `T`.
+Otherwise, or if nothing is found, the deallocation function’s name is
+looked up by searching for it in the global scope.
 A declaration of a placement deallocation function matches the
 declaration of a placement allocation function if it has the same number
 of parameters and, after parameter transformations [[dcl.fct]], all
 parameter types except the first are identical. If the lookup finds a

Diff to HTML by rtfpessoa