[expr.new] - C++11 → C++14

Files changed (1) hide show

tmp/tmplv4c0lhs/{from.md → to.md} +120 -59

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

@@ -112,35 +112,43 @@ denotes an array type), the *new-expression* yields a pointer to the
 initial element (if any) of the array. both `new int` and `new int[10]`
 have type `int*` and the type of `new int[i][10]` is `int (*)[10]` 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 an
-integral constant expression ([[expr.const]]) and evaluate to a
-strictly positive value. The *expression* in a *noptr-new-declarator*
-shall be of integral type, unscoped enumeration type, or a class type
-for which a single non-explicit conversion function to integral or
-unscoped enumeration type exists ([[class.conv]]). If the expression is
-of class type, the expression is converted by calling that conversion
-function, and the result of the conversion is used in place of the
-original expression. 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).
-When the value of the *expression* in a *noptr-new-declarator* is zero,
-the allocation function is called to allocate an array with no elements.
-If the value of that *expression* is less than zero or such that the
-size of the allocated object would exceed the implementation-defined
-limit, or if the *new-initializer* is a *braced-init-list* for which the
-number of *initializer-clause*s exceeds the number of elements to
-initialize, no storage is obtained and the *new-expression* terminates
-by throwing an exception of a type that would match a handler (
-[[except.handle]]) of type `std::bad_array_new_length` (
-[[new.badlength]]).
-A *new-expression* obtains 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 type, the allocation function’s name is `operator new` and the
@@ -158,24 +166,76 @@ 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.
-A *new-expression* passes the amount of space requested to the
-allocation function as the first argument of type `std::size_t`. That
-argument shall be no less than the size of the object being created; it
-may be greater than the size of the object being created only if the
-object is an array. For arrays of `char` and `unsigned char`, the
-difference between the result of the *new-expression* and the address
-returned by the allocation function shall be an integral multiple of the
-strictest fundamental alignment requirement ([[basic.align]]) of any
-object type whose size is no greater than the size of the array being
-created. Because allocation functions are assumed to return pointers to
-storage that is appropriately aligned for objects of any type with
-fundamental alignment, this constraint on array allocation overhead
-permits the common idiom of allocating character arrays into which
-objects of other types will later be placed.
 The *new-placement* syntax is used to supply additional arguments to an
 allocation function. If used, overload resolution is performed on a
 function call created by assembling an argument list consisting of the
 amount of space requested (the first argument) and the expressions in
@@ -220,12 +280,12 @@ necessarily be the same as that of the block if the object is an array.
 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 ([[dcl.init]]); if no initialization is
-  performed, the object has indeterminate value.
 - Otherwise, the *new-initializer* is interpreted according to the
   initialization rules of  [[dcl.init]] for direct-initialization.
 The invocation of the allocation function is indeterminately sequenced
 with respect to the evaluations of expressions in the *new-initializer*.
@@ -235,23 +295,24 @@ expressions in the *new-initializer* are evaluated if the allocation
 function returns the null pointer or exits using an exception.
 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]]). If the new expression creates an array of
-objects of class type, access and ambiguity control are done for the
-destructor ([[class.dtor]]).
 If any part of the object initialization described above[^19] 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. This is appropriate when
-the called allocation function does not allocate memory; otherwise, it
-is likely to result in a memory leak.
 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
@@ -260,19 +321,19 @@ 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. Any non-placement
-deallocation function matches a non-placement allocation function. If
-the lookup finds a single matching deallocation function, that function
-will be called; otherwise, no deallocation function will be called. If
-the lookup finds the two-parameter form of a usual deallocation
-function ([[basic.stc.dynamic.deallocation]]) 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.
 ``` cpp
 struct S {
   // Placement allocation function:
   static void* operator new(std::size_t, std::size_t);

 initial element (if any) of the array. both `new int` and `new int[10]`
 have type `int*` and the type of `new int[i][10]` is `int (*)[10]` 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 shall evaluate to a strictly positive value. The *expression* in a
+*noptr-new-declarator*is implicitly converted to `std::size_t`. 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).
+The *expression* in a *noptr-new-declarator* 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]])[^18] is less than
+  zero;
+- its value is such that the size of the allocated object would exceed
+  the implementation-defined limit (annex  [[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*, after converting to `std::size_t`, is a core
+constant expression and the expression is erroneous, the program is
+ill-formed. Otherwise, a *new-expression* with an erroneous expression
+does not call an allocation function and terminates by throwing an
+exception of a type that would match a handler ([[except.handle]]) of
+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.
+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 type, the allocation function’s name is `operator new` and the
 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*. 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:
+- the evaluation of `e1` is sequenced before the evaluation of `e2`, and
+- `e2` is evaluated whenever `e1` obtains storage, and
+- both `e1` and `e2` invoke the same replaceable global allocation
+  function, and
+- if the allocation function invoked by `e1` and `e2` is throwing, any
+  exceptions thrown in the evaluation of either `e1` or `e2` would be
+  first caught in the same handler, and
+- the pointer values produced by `e1` and `e2` are operands to evaluated
+  *delete-expression*s, and
+- the evaluation of `e2` is sequenced before the evaluation of the
+  *delete-expression* whose operand is the pointer value produced by
+  `e1`.
+``` cpp
+void mergeable(int x) {
+    // These allocations are safe for merging:
+    std::unique_ptr<char[]> a{new (std::nothrow) char[8]};
+    std::unique_ptr<char[]> b{new (std::nothrow) char[8]};
+    std::unique_ptr<char[]> c{new (std::nothrow) char[x]};
+    g(a.get(), b.get(), c.get());
+  }
+  void unmergeable(int x) {
+    std::unique_ptr<char[]> a{new char[8]};
+    try {
+      // Merging this allocation would change its catch handler.
+      std::unique_ptr<char[]> b{new char[x]};
+    } catch (const std::bad_alloc& e) {
+      std::cerr << "Allocation failed: " << e.what() << std::endl;
+      throw;
+    }
+  }
+```
+When a *new-expression* calls an allocation function and that allocation
+has not been extended, the *new-expression* passes the amount of space
+requested to the allocation function as the first argument of type
+`std::size_t`. That argument shall be no less than the size of the
+object being created; it may be greater than the size of the object
+being created only if the object is an array. For arrays of `char` and
+`unsigned char`, the difference between the result of the
+*new-expression* and the address returned by the allocation function
+shall be an integral multiple of the strictest fundamental alignment
+requirement ([[basic.align]]) of any object type whose size is no
+greater than the size of the array being created. Because allocation
+functions are assumed to return pointers to storage that is
+appropriately aligned for objects of any type with fundamental
+alignment, this constraint on array allocation overhead permits the
+common idiom of allocating character arrays into which objects of other
+types will later be placed.
+When a *new-expression* calls an allocation function and that allocation
+has been extended, the size argument to the allocation call shall be no
+greater than the sum of the sizes for the omitted calls as specified
+above, plus the size for the extended call had it not been extended,
+plus any padding necessary to align the allocated objects within the
+allocated memory.
 The *new-placement* syntax is used to supply additional arguments to an
 allocation function. If used, overload resolution is performed on a
 function call created by assembling an argument list consisting of the
 amount of space requested (the first argument) and the expressions in
 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 ([[dcl.init]]). If no initialization is
+  performed, the object has an indeterminate value.
 - Otherwise, the *new-initializer* is interpreted according to the
   initialization rules of  [[dcl.init]] for direct-initialization.
 The invocation of the allocation function is indeterminately sequenced
 with respect to the evaluations of expressions in the *new-initializer*.
 function returns the null pointer or exits using an exception.
 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]]). 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[^19] terminates
+by throwing an exception, storage has been obtained for the object, 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. This is appropriate when the called allocation function
+does not allocate memory; otherwise, it is likely to result in a memory
+leak.
 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
 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
+single matching deallocation function, that function will be called;
+otherwise, no deallocation function will be called. If the lookup finds
+the two-parameter form of a usual deallocation function (
+[[basic.stc.dynamic.deallocation]]) 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]])
 ``` cpp
 struct S {
   // Placement allocation function:
   static void* operator new(std::size_t, std::size_t);

Diff to HTML by rtfpessoa