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

Files changed (1) hide show

tmp/tmpik31x30m/{from.md → to.md} +44 -33

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

@@ -1,9 +1,9 @@
 #### 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
@@ -45,17 +45,17 @@ noptr-new-declarator:
 new-initializer:
     '(' expression-listₒₚₜ ')'
     braced-init-list
 ```
-If a placeholder type [[dcl.spec.auto]] appears in the
-*type-specifier-seq* of a *new-type-id* or *type-id* of a
-*new-expression*, the allocated type is deduced as follows: Let *init*
-be the *new-initializer*, if any, and `T` be the *new-type-id* or
-*type-id* of the *new-expression*, then the allocated type is the type
-deduced for the variable `x` in the invented declaration
-[[dcl.spec.auto]]:
 ``` cpp
 T x init ;
 ```
@@ -127,34 +127,41 @@ converted constant expression [[expr.const]] of type `std::size_t` and
 its value shall be greater than zero.
 [*Example 4*: Given the definition `int n = 42`, `new float[n][5]` is
 well-formed (because `n` is the *expression* of a
 *noptr-new-declarator*), but `new float[5][n]` is ill-formed (because
-`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
   `std::size_t` is less than zero;
 - the expression is of class type and its value before application of
-  the second standard conversion [[over.ics.user]][^23] is less than
   zero;
 - its value is such that the size of the allocated object would exceed
   the *implementation-defined* limit [[implimits]]; or
 - the *new-initializer* is a *braced-init-list* and the number of array
   elements for which initializers are provided (including the
   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
@@ -166,24 +173,34 @@ 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.
 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
@@ -192,11 +209,11 @@ storage by calling a deallocation function
 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 can be called by a
@@ -213,16 +230,12 @@ 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.
-[*Note 8*: Only *new-expression*s that would otherwise result in a call
-to a replaceable global allocation function can be evaluated in constant
-expressions [[expr.const]]. — *end note*]
 The implementation may extend the allocation of a *new-expression* `e1`
 to provide storage for a *new-expression* `e2` if the following would be
 true were the allocation not extended:
@@ -361,13 +374,13 @@ not be done, the deallocation function shall not be called, and the
 value of the *new-expression* shall be null.
 [*Note 11*: When the allocation function returns a value other than
 null, it must be a pointer to a block of storage in which space for the
 object has been reserved. The block of storage is assumed to be
-appropriately aligned and of the requested size. The address of the
-created object will not necessarily be the same as that of the block if
-the object is an array. — *end note*]
 A *new-expression* that creates an object of type `T` initializes that
 object as follows:
 - If the *new-initializer* is omitted, the object is default-initialized
@@ -379,18 +392,14 @@ object as follows:
 The invocation of the allocation function is sequenced before the
 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 [[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
@@ -415,11 +424,13 @@ single matching deallocation function, that function will be called;
 otherwise, no deallocation function will be called. If the lookup finds
 a usual deallocation function and that function, considered as a
 placement deallocation function, would have been selected as a match for
 the allocation function, the program is ill-formed. For a non-placement
 allocation function, the normal deallocation function lookup is used to
-find the matching deallocation function [[expr.delete]].
 [*Example 7*:
 ``` cpp
 struct S {

 #### New <a id="expr.new">[[expr.new]]</a>
+The *new-expression* attempts to create an object of the *type-id* or
+*new-type-id* [[dcl.name]] 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
 new-initializer:
     '(' expression-listₒₚₜ ')'
     braced-init-list
 ```
+If a placeholder type [[dcl.spec.auto]] or a placeholder for a deduced
+class type [[dcl.type.class.deduct]] appears in the *type-specifier-seq*
+of a *new-type-id* or *type-id* of a *new-expression*, the allocated
+type is deduced as follows: Let *init* be the *new-initializer*, if any,
+and `T` be the *new-type-id* or *type-id* of the *new-expression*, then
+the allocated type is the type deduced for the variable `x` in the
+invented declaration [[dcl.spec.auto]]:
 ``` cpp
 T x init ;
 ```
 its value shall be greater than zero.
 [*Example 4*: Given the definition `int n = 42`, `new float[n][5]` is
 well-formed (because `n` is the *expression* of a
 *noptr-new-declarator*), but `new float[5][n]` is ill-formed (because
+`n` is not a constant expression). Furthermore, `new float[0]` is
+well-formed (because `0` is the *expression* of a
+*noptr-new-declarator*, where a value of zero results in the allocation
+of an array with no elements), but `new float[n][0]` is ill-formed
+(because `0` is the *constant-expression* of a *noptr-new-declarator*,
+where only values greater than zero are allowed). — *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 value of the *expression* is
+invalid if
 - the expression is of non-class type and its value before converting to
   `std::size_t` is less than zero;
 - the expression is of class type and its value before application of
+  the second standard conversion [[over.ics.user]][^21] is less than
   zero;
 - its value is such that the size of the allocated object would exceed
   the *implementation-defined* limit [[implimits]]; or
 - the *new-initializer* is a *braced-init-list* and the number of array
   elements for which initializers are provided (including the
   terminating `'\0'` in a *string-literal* [[lex.string]]) exceeds the
   number of elements to initialize.
+If the value of the *expression* is invalid 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
     `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.
+If the allocated type is an array, the *new-initializer* is a
+*braced-init-list*, and the *expression* is potentially-evaluated and
+not a core constant expression, the semantic constraints of
+copy-initializing a hypothetical element of the array from an empty
+initializer list are checked [[dcl.init.list]].
+[*Note 5*: The array can contain more elements than there are elements
+in the *braced-init-list*, requiring initialization of the remainder of
+the array elements from an empty initializer list. — *end note*]
 Objects created by a *new-expression* have dynamic storage duration
 [[basic.stc.dynamic]].
+[*Note 6*:  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 7*: 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
 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 8*: An implementation is expected 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
 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 a replaceable
+allocation function is always omitted [[expr.const]].
 The implementation may extend the allocation of a *new-expression* `e1`
 to provide storage for a *new-expression* `e2` if the following would be
 true were the allocation not extended:
 value of the *new-expression* shall be null.
 [*Note 11*: When the allocation function returns a value other than
 null, it must be a pointer to a block of storage in which space for the
 object has been reserved. The block of storage is assumed to be
+appropriately aligned [[basic.align]] and of the requested size. The
+address of the created object will not necessarily be the same as that
+of the block if the object is an array. — *end note*]
 A *new-expression* that creates an object of type `T` initializes that
 object as follows:
 - If the *new-initializer* is omitted, the object is default-initialized
 The invocation of the allocation function is sequenced before the
 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 array of objects of class type, the
+destructor is potentially invoked [[class.dtor]].
+If any part of the object initialization described above[^22]
 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
 otherwise, no deallocation function will be called. If the lookup finds
 a usual deallocation function and that function, considered as a
 placement deallocation function, would have been selected as a match for
 the allocation function, the program is ill-formed. For a non-placement
 allocation function, the normal deallocation function lookup is used to
+find the matching deallocation function [[expr.delete]]. In any case,
+the matching deallocation function (if any) shall be non-deleted and
+accessible from the point where the *new-expression* appears.
 [*Example 7*:
 ``` cpp
 struct S {

Diff to HTML by rtfpessoa