[basic.memobj] - C++23 → Trunk

Files changed (1) hide show

tmp/tmpnfr6j_yf/{from.md → to.md} +377 -265

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

@@ -3,27 +3,23 @@
 ### Memory model <a id="intro.memory">[[intro.memory]]</a>
 The fundamental storage unit in the C++ memory model is the *byte*. A
 byte is at least large enough to contain the ordinary literal encoding
 of any element of the basic literal character set [[lex.charset]] and
-the eight-bit code units of the Unicode[^5]
-UTF-8 encoding form and is composed of a contiguous sequence of
-bits,[^6]
-the number of which is *implementation-defined*. The least significant
-bit is called the *low-order bit*; the most significant bit is called
-the *high-order bit*. The memory available to a C++ program consists of
-one or more sequences of contiguous bytes. Every byte has a unique
-address.
 [*Note 1*: The representation of types is described in
 [[basic.types.general]]. — *end note*]
-A *memory location* is either an object of scalar type that is not a
-bit-field or a maximal sequence of adjacent bit-fields all having
-nonzero width.
 [*Note 2*: Various features of the language, such as references and
 virtual functions, might involve additional memory locations that are
 not accessible to programs but are managed by the
 implementation. — *end note*]
@@ -94,21 +90,21 @@ Objects can contain other objects, called *subobjects*. A subobject can
 be a *member subobject* [[class.mem]], a *base class subobject*
 [[class.derived]], or an array element. An object that is not a
 subobject of any other object is called a *complete object*. If an
 object is created in storage associated with a member subobject or array
 element *e* (which may or may not be within its lifetime), the created
-object is a subobject of *e*’s containing object if:
 - the lifetime of *e*’s containing object has begun and not ended, and
 - the storage for the new object exactly overlays the storage location
   associated with *e*, and
 - the new object is of the same type as *e* (ignoring cv-qualification).
 If a complete object is created [[expr.new]] in storage associated with
 another object *e* of type “array of N `unsigned char`” or of type
 “array of N `std::byte`” [[cstddef.syn]], that array *provides storage*
-for the created object if:
 - the lifetime of *e* has begun and not ended, and
 - the storage for the new object fits entirely within *e*, and
 - there is no array object that satisfies these constraints nested
   within *e*.
@@ -118,10 +114,12 @@ another object, the lifetime of that object ends because its storage was
 reused [[basic.life]]. — *end note*]
 [*Example 1*:
 ``` cpp
 template<typename ...T>
 struct AlignedUnion {
   alignas(T...) unsigned char data[max(sizeof(T)...)];
 };
 int f() {
@@ -132,20 +130,20 @@ int f() {
   return *c + *d;                       // OK
 }
 struct A { unsigned char a[32]; };
 struct B { unsigned char b[16]; };
-A a;
 B *b = new (a.a + 8) B;                 // a.a provides storage for *b
 int *p = new (b->b + 4) int;            // b->b provides storage for *p
                                         // a.a does not provide storage for *p (directly),
                                         // but *p is nested within a (see below)
 ```
 — *end example*]
-An object *a* is *nested within* another object *b* if:
 - *a* is a subobject of *b*, or
 - *b* provides storage for *a*, or
 - there exists an object *c* where *a* is nested within *c*, and *c* is
   nested within *b*.
@@ -186,23 +184,45 @@ the circumstances under which the object has zero size are
 object with nonzero size shall occupy one or more bytes of storage,
 including every byte that is occupied in full or in part by any of its
 subobjects. An object of trivially copyable or standard-layout type
 [[basic.types.general]] shall occupy contiguous bytes of storage.
 Unless an object is a bit-field or a subobject of zero size, the address
 of that object is the address of the first byte it occupies. Two objects
 with overlapping lifetimes that are not bit-fields may have the same
-address if one is nested within the other, or if at least one is a
-subobject of zero size and they are of different types; otherwise, they
-have distinct addresses and occupy disjoint bytes of storage.[^7]
 [*Example 2*:
 ``` cpp
 static const char test1 = 'x';
 static const char test2 = 'x';
 const bool b = &test1 != &test2;        // always true
 ```
 — *end example*]
 The address of a non-bit-field subobject of zero size is the address of
@@ -211,16 +231,16 @@ subobject.
 Some operations are described as *implicitly creating objects* within a
 specified region of storage. For each operation that is specified as
 implicitly creating objects, that operation implicitly creates and
 starts the lifetime of zero or more objects of implicit-lifetime types
-[[basic.types.general]] in its specified region of storage if doing so
-would result in the program having defined behavior. If no such set of
-objects would give the program defined behavior, the behavior of the
-program is undefined. If multiple such sets of objects would give the
-program defined behavior, it is unspecified which such set of objects is
-created.
 [*Note 4*: Such operations do not start the lifetimes of subobjects of
 such objects that are not themselves of implicit-lifetime
 types. — *end note*]
@@ -253,32 +273,123 @@ X *make_x() {
 }
 ```
 — *end example*]
-An operation that begins the lifetime of an array of `unsigned char` or
-`std::byte` implicitly creates objects within the region of storage
-occupied by the array.
 [*Note 5*: The array object provides storage for these
 objects. — *end note*]
-Any implicit or explicit invocation of a function named `operator new`
-or `operator new[]` implicitly creates objects in the returned region of
-storage and returns a pointer to a suitable created object.
 [*Note 6*: Some functions in the C++ standard library implicitly create
 objects
-[[obj.lifetime]], [[allocator.traits.members]], [[c.malloc]], [[cstring.syn]], [[bit.cast]]. — *end note*]
 ### Lifetime <a id="basic.life">[[basic.life]]</a>
 The *lifetime* of an object or reference is a runtime property of the
 object or reference. A variable is said to have *vacuous initialization*
-if it is default-initialized and, if it is of class type or a (possibly
-multidimensional) array thereof, that class type has a trivial default
-constructor. The lifetime of an object of type `T` begins when:
 - storage with the proper alignment and size for type `T` is obtained,
   and
 - its initialization (if any) is complete (including vacuous
   initialization) [[dcl.init]],
@@ -293,10 +404,29 @@ except as described in [[allocator.members]]. The lifetime of an object
 - if `T` is a non-class type, the object is destroyed, or
 - if `T` is a class type, the destructor call starts, or
 - the storage which the object occupies is released, or is reused by an
   object that is not nested within *o* [[intro.object]].
 The lifetime of a reference begins when its initialization is complete.
 The lifetime of a reference ends as if it were a scalar object requiring
 storage.
 [*Note 1*:  [[class.base.init]] describes the lifetime of base and
@@ -325,22 +455,22 @@ In this case, the destructor is not implicitly invoked.
 [*Note 4*: The correct behavior of a program often depends on the
 destructor being invoked for each object of class type. — *end note*]
 Before the lifetime of an object has started but after the storage which
-the object will occupy has been allocated[^8]
-or, after the lifetime of an object has ended and before the storage
 which the object occupied is reused or released, any pointer that
 represents the address of the storage location where the object will be
 or was located may be used but only in limited ways. For an object under
 construction or destruction, see  [[class.cdtor]]. Otherwise, such a
 pointer refers to allocated storage [[basic.stc.dynamic.allocation]],
 and using the pointer as if the pointer were of type `void*` is
 well-defined. Indirection through such a pointer is permitted but the
 resulting lvalue may only be used in limited ways, as described below.
-The program has undefined behavior if:
 - the pointer is used as the operand of a *delete-expression*,
 - the pointer is used to access a non-static data member or call a
   non-static member function of the object, or
 - the pointer is implicitly converted [[conv.ptr]] to a pointer to a
@@ -350,11 +480,11 @@ The program has undefined behavior if:
   cv `void`, or to pointer to cv `void` and subsequently to pointer to
   cv `char`, cv `unsigned char`, or cv `std::byte` [[cstddef.syn]], or
 - the pointer is used as the operand of a `dynamic_cast`
   [[expr.dynamic.cast]].
-[*Example 1*:
 ``` cpp
 #include <cstdlib>
 struct B {
@@ -383,36 +513,32 @@ void g() {
 ```
 — *end example*]
 Similarly, before the lifetime of an object has started but after the
-storage which the object will occupy has been allocated or, after the
 lifetime of an object has ended and before the storage which the object
 occupied is reused or released, any glvalue that refers to the original
 object may be used but only in limited ways. For an object under
 construction or destruction, see  [[class.cdtor]]. Otherwise, such a
 glvalue refers to allocated storage [[basic.stc.dynamic.allocation]],
 and using the properties of the glvalue that do not depend on its value
-is well-defined. The program has undefined behavior if:
 - the glvalue is used to access the object, or
 - the glvalue is used to call a non-static member function of the
   object, or
 - the glvalue is bound to a reference to a virtual base class
   [[dcl.init.ref]], or
 - the glvalue is used as the operand of a `dynamic_cast`
   [[expr.dynamic.cast]] or as the operand of `typeid`.
-If, after the lifetime of an object has ended and before the storage
-which the object occupied is reused or released, a new object is created
-at the storage location which the original object occupied, a pointer
-that pointed to the original object, a reference that referred to the
-original object, or the name of the original object will automatically
-refer to the new object and, once the lifetime of the new object has
-started, can be used to manipulate the new object, if the original
-object is transparently replaceable (see below) by the new object. An
-object o₁ is *transparently replaceable* by an object o₂ if:
 - the storage that o₂ occupies exactly overlays the storage that o₁
   occupied, and
 - o₁ and o₂ are of the same type (ignoring the top-level cv-qualifiers),
   and
@@ -421,11 +547,20 @@ object o₁ is *transparently replaceable* by an object o₂ if:
   [[intro.object]], and
 - either o₁ and o₂ are both complete objects, or o₁ and o₂ are direct
   subobjects of objects p₁ and p₂, respectively, and p₁ is transparently
   replaceable by p₂.
-[*Example 2*:
 ``` cpp
 struct C {
   int i;
   void f();
@@ -447,25 +582,25 @@ c1 = c2;                        // well-defined
 c1.f();                         // well-defined; c1 refers to a new object of type C
 ```
 — *end example*]
-[*Note 5*: If these conditions are not met, a pointer to the new object
 can be obtained from a pointer that represents the address of its
 storage by calling `std::launder` [[ptr.launder]]. — *end note*]
 If a program ends the lifetime of an object of type `T` with static
 [[basic.stc.static]], thread [[basic.stc.thread]], or automatic
 [[basic.stc.auto]] storage duration and if `T` has a non-trivial
-destructor,[^9]
 and another object of the original type does not occupy that same
 storage location when the implicit destructor call takes place, the
 behavior of the program is undefined. This is true even if the block is
 exited with an exception.
-[*Example 3*:
 ``` cpp
 class T { };
 struct B {
   ~B();
@@ -482,11 +617,11 @@ void h() {
 Creating a new object within the storage that a const, complete object
 with static, thread, or automatic storage duration occupies, or within
 the storage that such a const object used to occupy before its lifetime
 ended, results in undefined behavior.
-[*Example 4*:
 ``` cpp
 struct B {
   B();
   ~B();
@@ -500,67 +635,114 @@ void h() {
 }
 ```
 — *end example*]
-In this subclause, “before” and “after” refer to the “happens before”
-relation [[intro.multithread]].
-[*Note 6*: Therefore, undefined behavior results if an object that is
-being constructed in one thread is referenced from another thread
-without adequate synchronization. — *end note*]
-### Indeterminate values <a id="basic.indet">[[basic.indet]]</a>
 When storage for an object with automatic or dynamic storage duration is
-obtained, the object has an *indeterminate value*, and if no
-initialization is performed for the object, that object retains an
-indeterminate value until that value is replaced [[expr.ass]].
-[*Note 1*: Objects with static or thread storage duration are
 zero-initialized, see  [[basic.start.static]]. — *end note*]
-If an indeterminate value is produced by an evaluation, the behavior is
-undefined except in the following cases:
-- If an indeterminate value of unsigned ordinary character type
-  [[basic.fundamental]] or `std::byte` type [[cstddef.syn]] is produced
-  by the evaluation of:
   - the second or third operand of a conditional expression
     [[expr.cond]],
   - the right operand of a comma expression [[expr.comma]],
   - the operand of a cast or conversion
     [[conv.integral]], [[expr.type.conv]], [[expr.static.cast]], [[expr.cast]]
     to an unsigned ordinary character type or `std::byte` type
     [[cstddef.syn]], or
   - a discarded-value expression [[expr.context]],
-  then the result of the operation is an indeterminate value.
-- If an indeterminate value of unsigned ordinary character type or
-  `std::byte` type is produced by the evaluation of the right operand of
- a simple assignment operator [[expr.ass]] whose first operand is an
- lvalue of unsigned ordinary character type or `std::byte` type, an
- indeterminate value replaces the value of the object referred to by
- the left operand.
-- If an indeterminate value of unsigned ordinary character type is
- produced by the evaluation of the initialization expression when
-  initializing an object of unsigned ordinary character type, that
- object is initialized to an indeterminate value.
 - If an indeterminate value of unsigned ordinary character type or
   `std::byte` type is produced by the evaluation of the initialization
   expression when initializing an object of `std::byte` type, that
-  object is initialized to an indeterminate value.
 [*Example 1*:
 ``` cpp
 int f(bool b) {
-  unsigned char c;
-  unsigned char d = c; // OK, d has an indeterminate value
   int e = d;                    // undefined behavior
   return b ? d : 0;             // undefined behavior if b is true
 }
 ```
 — *end example*]
 ### Storage duration <a id="basic.stc">[[basic.stc]]</a>
@@ -575,24 +757,24 @@ 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.[^10]
 #### Static storage duration <a id="basic.stc.static">[[basic.stc.static]]</a>
 All variables which
@@ -629,18 +811,22 @@ 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>
-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
 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.elision]].
@@ -661,29 +847,25 @@ global *deallocation functions* `operator delete` and
 [[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*) 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;
-[[nodiscard]] void* operator new[](std::size_t);
-[[nodiscard]] 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;
@@ -738,11 +920,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.[^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:
@@ -757,12 +939,12 @@ call shall represent the address of storage that is aligned as follows:
 An allocation function that fails to allocate storage can invoke the
 currently installed new-handler function [[new.handler]], if any.
 [*Note 3*:  A program-supplied allocation function can obtain the
-address of the currently installed `new_handler` using the
-`std::get_new_handler` function [[get.new.handler]]. — *end note*]
 An allocation function that has a non-throwing exception specification
 [[except.spec]] indicates failure by returning a null pointer value. Any
 other allocation function never returns a null pointer value and
 indicates failure only by throwing an exception [[except.throw]] of a
@@ -777,11 +959,13 @@ calls to the functions in the C++ standard library.
 [*Note 4*: 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>
 A deallocation function that is not a class member function shall belong
@@ -801,11 +985,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`,[^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
@@ -822,129 +1006,41 @@ 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.
-#### 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]].
-### Alignment <a id="basic.align">[[basic.align]]</a>
-Object types have *alignment requirements*
-[[basic.fundamental]], [[basic.compound]] which place restrictions on
-the addresses at which an object of that type may be allocated. An
-*alignment* is an *implementation-defined* integer value representing
-the number of bytes between successive addresses at which a given object
-can be allocated. An object type imposes an alignment requirement on
-every object of that type; stricter alignment can be requested using the
-alignment specifier [[dcl.align]].
-A *fundamental alignment* is represented by an alignment less than or
-equal to the greatest alignment supported by the implementation in all
-contexts, which is equal to `alignof(std::max_align_t)`
-[[support.types]]. The alignment required for a type may be different
-when it is used as the type of a complete object and when it is used as
-the type of a subobject.
-[*Example 1*:
-``` cpp
-struct B { long double d; };
-struct D : virtual B { char c; };
-```
-When `D` is the type of a complete object, it will have a subobject of
-type `B`, so it must be aligned appropriately for a `long double`. If
-`D` appears as a subobject of another object that also has `B` as a
-virtual base class, the `B` subobject might be part of a different
-subobject, reducing the alignment requirements on the `D` subobject.
-— *end example*]
-The result of the `alignof` operator reflects the alignment requirement
-of the type in the complete-object case.
-An *extended alignment* is represented by an alignment greater than
-`alignof(std::max_align_t)`. It is *implementation-defined* whether any
-extended alignments are supported and the contexts in which they are
-supported [[dcl.align]]. A type having an extended alignment requirement
-is an *over-aligned type*.
-[*Note 1*: Every over-aligned type is or contains a class type to which
-extended alignment applies (possibly through a non-static data
-member). — *end note*]
-A *new-extended alignment* is represented by an alignment greater than
-`__STDCPP_DEFAULT_NEW_ALIGNMENT__` [[cpp.predefined]].
-Alignments are represented as values of the type `std::size_t`. Valid
-alignments include only those values returned by an `alignof` expression
-for the fundamental types plus an additional *implementation-defined*
-set of values, which may be empty. Every alignment value shall be a
-non-negative integral power of two.
-Alignments have an order from *weaker* to *stronger* or *stricter*
-alignments. Stricter alignments have larger alignment values. An address
-that satisfies an alignment requirement also satisfies any weaker valid
-alignment requirement.
-The alignment requirement of a complete type can be queried using an
-`alignof` expression [[expr.alignof]]. Furthermore, the narrow character
-types [[basic.fundamental]] shall have the weakest alignment
-requirement.
-[*Note 2*: This enables the ordinary character types to be used as the
-underlying type for an aligned memory area [[dcl.align]]. — *end note*]
-Comparing alignments is meaningful and provides the obvious results:
-- Two alignments are equal when their numeric values are equal.
-- Two alignments are different when their numeric values are not equal.
-- When an alignment is larger than another it represents a stricter
-  alignment.
-[*Note 3*: The runtime pointer alignment function [[ptr.align]] can be
-used to obtain an aligned pointer within a buffer; an
-*alignment-specifier* [[dcl.align]] can be used to align storage
-explicitly. — *end note*]
-If a request for a specific extended alignment in a specific context is
-not supported by an implementation, the program is ill-formed.
 ### Temporary objects <a id="class.temporary">[[class.temporary]]</a>
-Temporary objects are created
-- when a prvalue is converted to an xvalue [[conv.rval]],
 - when needed by the implementation to pass or return an object of
- trivially copyable type (see below), and
-- when throwing an exception [[except.throw]]. \[*Note 1*: The lifetime
-  of exception objects is described in  [[except.throw]]. — *end note*]
 Even when the creation of the temporary object is unevaluated
 [[expr.context]], all the semantic restrictions shall be respected as if
 the temporary object had been created and later destroyed.
-[*Note 2*: This includes accessibility [[class.access]] and whether it
 is deleted, for the constructor selected and for the destructor.
 However, in the special case of the operand of a *decltype-specifier*
 [[dcl.type.decltype]], no temporary is introduced, so the foregoing does
 not apply to such a prvalue. — *end note*]
 The materialization of a temporary object is generally delayed as long
 as possible in order to avoid creating unnecessary temporary objects.
-[*Note 3*:
 Temporary objects are materialized:
 - when binding a reference to a prvalue
   [[dcl.init.ref]], [[expr.type.conv]], [[expr.dynamic.cast]], [[expr.static.cast]], [[expr.const.cast]], [[expr.cast]],
-- when performing member access on a class prvalue
   [[expr.ref]], [[expr.mptr.oper]],
 - when performing an array-to-pointer conversion or subscripting on an
   array prvalue [[conv.array]], [[expr.sub]],
 - when initializing an object of type `std::initializer_list<T>` from a
   *braced-init-list* [[dcl.init.list]],
 - for certain unevaluated operands [[expr.typeid]], [[expr.sizeof]], and
@@ -992,49 +1088,56 @@ result is constructed directly in `c`. On the other hand, the expression
 materialized so that the reference parameter of `X::operator=(const X&)`
 can bind to it.
 — *end example*]
-When an object of class type `X` is passed to or returned from a
-function, if `X` has at least one eligible copy or move constructor
-[[special]], each such constructor is trivial, and the destructor of `X`
-is either trivial or deleted, implementations are permitted to create a
-temporary object to hold the function parameter or result object. The
-temporary object is constructed from the function argument or return
-value, respectively, and the function’s parameter or return object is
-initialized as if by using the eligible trivial constructor to copy the
-temporary (even if that constructor is inaccessible or would not be
-selected by overload resolution to perform a copy or move of the
-object).
-[*Note 4*: This latitude is granted to allow objects of class type to
-be passed to or returned from functions in registers. — *end note*]
-When an implementation introduces a temporary object of a class that has
-a non-trivial constructor [[class.default.ctor]], [[class.copy.ctor]],
-it shall ensure that a constructor is called for the temporary object.
-Similarly, the destructor shall be called for a temporary with a
-non-trivial destructor [[class.dtor]]. Temporary objects are destroyed
-as the last step in evaluating the full-expression [[intro.execution]]
-that (lexically) contains the point where they were created. This is
-true even if that evaluation ends in throwing an exception. The value
-computations and side effects of destroying a temporary object are
-associated only with the full-expression, not with any specific
-subexpression.
-There are four contexts in which temporaries are destroyed at a
-different point than the end of the full-expression. The first context
-is when a default constructor is called to initialize an element of an
-array with no corresponding initializer [[dcl.init]]. The second context
-is when a copy constructor is called to copy an element of an array
-while the entire array is copied
 [[expr.prim.lambda.capture]], [[class.copy.ctor]]. In either case, if
 the constructor has one or more default arguments, the destruction of
 every temporary created in a default argument is sequenced before the
 construction of the next array element, if any.
-The third context is when a reference binds to a temporary object.[^13]
 The temporary object to which the reference is bound or the temporary
 object that is the complete object of a subobject to which the reference
 is bound persists for the lifetime of the reference if the glvalue to
 which the reference is bound was obtained through one of the following:
@@ -1076,11 +1179,11 @@ int&& c = cond ? id<int[3]>{1, 2, 3}[i] : static_cast<int&&>(0);
                                             // exactly one of the two temporaries is lifetime-extended
 ```
 — *end example*]
-[*Note 5*:
 An explicit type conversion [[expr.type.conv]], [[expr.cast]] is
 interpreted as a sequence of elementary casts, covered above.
 [*Example 3*:
@@ -1091,11 +1194,11 @@ const int& x = (const int&)1;   // temporary for value 1 has same lifetime as x
 — *end example*]
 — *end note*]
-[*Note 6*:
 If a temporary object has a reference member initialized by another
 temporary object, lifetime extension applies recursively to such a
 member’s initializer.
@@ -1119,43 +1222,52 @@ The exceptions to this lifetime rule are:
   containing the call.
 - A temporary object bound to a reference element of an aggregate of
   class type initialized from a parenthesized *expression-list*
   [[dcl.init]] persists until the completion of the full-expression
   containing the *expression-list*.
-- The lifetime of a temporary bound to the returned value in a function
-  `return` statement [[stmt.return]] is not extended; the temporary is
-  destroyed at the end of the full-expression in the `return` statement.
 - A temporary bound to a reference in a *new-initializer* [[expr.new]]
   persists until the completion of the full-expression containing the
   *new-initializer*.
-  \[*Note 7*: This might introduce a dangling reference. — *end note*]
   \[*Example 5*:
   ``` cpp
   struct S { int mi; const std::pair<int,int>& mp; };
   S a { 1, {2,3} };
   S* p = new S{ 1, {2,3} };       // creates dangling reference
   ```
   — *end example*]
-The fourth context is when a temporary object other than a function
-parameter object is created in the *for-range-initializer* of a
-range-based `for` statement. If such a temporary object would otherwise
-be destroyed at the end of the *for-range-initializer* full-expression,
-the object persists for the lifetime of the reference initialized by the
-*for-range-initializer*.
-The destruction of a temporary whose lifetime is not extended beyond the
-full-expression in which it was created is sequenced before the
-destruction of every temporary which is constructed earlier in the same
-full-expression. If the lifetime of two or more temporaries with
-lifetimes extending beyond the full-expressions in which they were
-created ends at the same point, these temporaries are destroyed at that
-point in the reverse order of the completion of their construction. In
-addition, the destruction of such temporaries shall take into account
-the ordering of destruction of objects with static, thread, or automatic
-storage duration
 [[basic.stc.static]], [[basic.stc.thread]], [[basic.stc.auto]]; that is,
 if `obj1` is an object with the same storage duration as the temporary
 and created before the temporary is created the temporary shall be
 destroyed before `obj1` is destroyed; if `obj2` is an object with the
 same storage duration as the temporary and created after the temporary

 ### Memory model <a id="intro.memory">[[intro.memory]]</a>
 The fundamental storage unit in the C++ memory model is the *byte*. A
 byte is at least large enough to contain the ordinary literal encoding
 of any element of the basic literal character set [[lex.charset]] and
+the eight-bit code units of the Unicode UTF-8 encoding form and is
+composed of a contiguous sequence of bits,[^5]
+the number of which is *implementation-defined*. The memory available to
+a C++ program consists of one or more sequences of contiguous bytes.
+Every byte has a unique address.
 [*Note 1*: The representation of types is described in
 [[basic.types.general]]. — *end note*]
+A *memory location* is the storage occupied by the object representation
+of either an object of scalar type that is not a bit-field or a maximal
+sequence of adjacent bit-fields all having nonzero width.
 [*Note 2*: Various features of the language, such as references and
 virtual functions, might involve additional memory locations that are
 not accessible to programs but are managed by the
 implementation. — *end note*]
 be a *member subobject* [[class.mem]], a *base class subobject*
 [[class.derived]], or an array element. An object that is not a
 subobject of any other object is called a *complete object*. If an
 object is created in storage associated with a member subobject or array
 element *e* (which may or may not be within its lifetime), the created
+object is a subobject of *e*’s containing object if
 - the lifetime of *e*’s containing object has begun and not ended, and
 - the storage for the new object exactly overlays the storage location
   associated with *e*, and
 - the new object is of the same type as *e* (ignoring cv-qualification).
 If a complete object is created [[expr.new]] in storage associated with
 another object *e* of type “array of N `unsigned char`” or of type
 “array of N `std::byte`” [[cstddef.syn]], that array *provides storage*
+for the created object if
 - the lifetime of *e* has begun and not ended, and
 - the storage for the new object fits entirely within *e*, and
 - there is no array object that satisfies these constraints nested
   within *e*.
 reused [[basic.life]]. — *end note*]
 [*Example 1*:
 ``` cpp
+// assumes that sizeof(int) is equal to 4
 template<typename ...T>
 struct AlignedUnion {
   alignas(T...) unsigned char data[max(sizeof(T)...)];
 };
 int f() {
   return *c + *d;                       // OK
 }
 struct A { unsigned char a[32]; };
 struct B { unsigned char b[16]; };
+alignas(int) A a;
 B *b = new (a.a + 8) B;                 // a.a provides storage for *b
 int *p = new (b->b + 4) int;            // b->b provides storage for *p
                                         // a.a does not provide storage for *p (directly),
                                         // but *p is nested within a (see below)
 ```
 — *end example*]
+An object *a* is *nested within* another object *b* if
 - *a* is a subobject of *b*, or
 - *b* provides storage for *a*, or
 - there exists an object *c* where *a* is nested within *c*, and *c* is
   nested within *b*.
 object with nonzero size shall occupy one or more bytes of storage,
 including every byte that is occupied in full or in part by any of its
 subobjects. An object of trivially copyable or standard-layout type
 [[basic.types.general]] shall occupy contiguous bytes of storage.
+An object is a *potentially non-unique object* if it is
+- a string literal object [[lex.string]],
+- the backing array of an initializer list [[dcl.init.ref]], or
+- the object introduced by a call to `std::meta::reflect_constant_array`
+  or `std::meta::reflect_constant_string` [[meta.define.static]], or
+- a subobject thereof.
 Unless an object is a bit-field or a subobject of zero size, the address
 of that object is the address of the first byte it occupies. Two objects
 with overlapping lifetimes that are not bit-fields may have the same
+address if
+- one is nested within the other,
+- at least one is a subobject of zero size and they are not of similar
+  types [[conv.qual]], or
+- they are both potentially non-unique objects;
+otherwise, they have distinct addresses and occupy disjoint bytes of
+storage.[^6]
 [*Example 2*:
 ``` cpp
 static const char test1 = 'x';
 static const char test2 = 'x';
 const bool b = &test1 != &test2;        // always true
+static const char (&r) [] = "x";
+static const char *s = "x";
+static std::initializer_list<char> il = { 'x' };
+const bool b2 = r != il.begin();        // unspecified result
+const bool b3 = r != s;                 // unspecified result
+const bool b4 = il.begin() != &test1;   // always true
+const bool b5 = r != &test1;            // always true
 ```
 — *end example*]
 The address of a non-bit-field subobject of zero size is the address of
 Some operations are described as *implicitly creating objects* within a
 specified region of storage. For each operation that is specified as
 implicitly creating objects, that operation implicitly creates and
 starts the lifetime of zero or more objects of implicit-lifetime types
+[[term.implicit.lifetime.type]] in its specified region of storage if
+doing so would result in the program having defined behavior. If no such
+set of objects would give the program defined behavior, the behavior of
+the program is undefined. If multiple such sets of objects would give
+the program defined behavior, it is unspecified which such set of
+objects is created.
 [*Note 4*: Such operations do not start the lifetimes of subobjects of
 such objects that are not themselves of implicit-lifetime
 types. — *end note*]
 }
 ```
 — *end example*]
+Except during constant evaluation, an operation that begins the lifetime
+of an array of `unsigned char` or `std::byte` implicitly creates objects
+within the region of storage occupied by the array.
 [*Note 5*: The array object provides storage for these
 objects. — *end note*]
+Except during constant evaluation, any implicit or explicit invocation
+of a function named `operator new` or `operator new[]` implicitly
+creates objects in the returned region of storage and returns a pointer
+to a suitable created object.
 [*Note 6*: Some functions in the C++ standard library implicitly create
 objects
+[[obj.lifetime]], [[c.malloc]], [[mem.res.public]], [[bit.cast]], [[cstring.syn]]. — *end note*]
+### Alignment <a id="basic.align">[[basic.align]]</a>
+Object types have *alignment requirements*
+[[basic.fundamental]], [[basic.compound]] which place restrictions on
+the addresses at which an object of that type may be allocated. An
+*alignment* is an *implementation-defined* integer value representing
+the number of bytes between successive addresses at which a given object
+can be allocated. An object type imposes an alignment requirement on
+every object of that type; stricter alignment can be requested using the
+alignment specifier [[dcl.align]]. Attempting to create an object
+[[intro.object]] in storage that does not meet the alignment
+requirements of the object’s type is undefined behavior.
+A *fundamental alignment* is represented by an alignment less than or
+equal to the greatest alignment supported by the implementation in all
+contexts, which is equal to `alignof(std::max_align_t)`
+[[support.types]]. The alignment required for a type may be different
+when it is used as the type of a complete object and when it is used as
+the type of a subobject.
+[*Example 1*:
+``` cpp
+struct B { long double d; };
+struct D : virtual B { char c; };
+```
+When `D` is the type of a complete object, it will have a subobject of
+type `B`, so it must be aligned appropriately for a `long double`. If
+`D` appears as a subobject of another object that also has `B` as a
+virtual base class, the `B` subobject might be part of a different
+subobject, reducing the alignment requirements on the `D` subobject.
+— *end example*]
+The result of the `alignof` operator reflects the alignment requirement
+of the type in the complete-object case.
+An *extended alignment* is represented by an alignment greater than
+`alignof(std::max_align_t)`. It is *implementation-defined* whether any
+extended alignments are supported and the contexts in which they are
+supported [[dcl.align]]. A type having an extended alignment requirement
+is an *over-aligned type*.
+[*Note 1*: Every over-aligned type is or contains a class type to which
+extended alignment applies (possibly through a non-static data
+member). — *end note*]
+A *new-extended alignment* is represented by an alignment greater than
+`__STDCPP_DEFAULT_NEW_ALIGNMENT__` [[cpp.predefined]].
+Alignments are represented as values of the type `std::size_t`. Valid
+alignments include only those values returned by an `alignof` expression
+for the fundamental types plus an additional *implementation-defined*
+set of values, which may be empty. Every alignment value shall be a
+non-negative integral power of two.
+Alignments have an order from *weaker* to *stronger* or *stricter*
+alignments. Stricter alignments have larger alignment values. An address
+that satisfies an alignment requirement also satisfies any weaker valid
+alignment requirement.
+The alignment requirement of a complete type can be queried using an
+`alignof` expression [[expr.alignof]]. Furthermore, the narrow character
+types [[basic.fundamental]] shall have the weakest alignment
+requirement.
+[*Note 2*: This enables the ordinary character types to be used as the
+underlying type for an aligned memory area [[dcl.align]]. — *end note*]
+Comparing alignments is meaningful and provides the obvious results:
+- Two alignments are equal when their numeric values are equal.
+- Two alignments are different when their numeric values are not equal.
+- When an alignment is larger than another it represents a stricter
+  alignment.
+[*Note 3*: The runtime pointer alignment function [[ptr.align]] can be
+used to obtain an aligned pointer within a buffer; an
+*alignment-specifier* [[dcl.align]] can be used to align storage
+explicitly. — *end note*]
+If a request for a specific extended alignment in a specific context is
+not supported by an implementation, the program is ill-formed.
 ### Lifetime <a id="basic.life">[[basic.life]]</a>
+In this subclause, “before” and “after” refer to the “happens before”
+relation [[intro.multithread]].
 The *lifetime* of an object or reference is a runtime property of the
 object or reference. A variable is said to have *vacuous initialization*
+if it is default-initialized, no other initialization is performed, and,
+if it is of class type or a (possibly multidimensional) array thereof, a
+trivial constructor of that class type is selected for the
+default-initialization. The lifetime of an object of type `T` begins
+when:
 - storage with the proper alignment and size for type `T` is obtained,
   and
 - its initialization (if any) is complete (including vacuous
   initialization) [[dcl.init]],
 - if `T` is a non-class type, the object is destroyed, or
 - if `T` is a class type, the destructor call starts, or
 - the storage which the object occupies is released, or is reused by an
   object that is not nested within *o* [[intro.object]].
+When evaluating a *new-expression*, storage is considered reused after
+it is returned from the allocation function, but before the evaluation
+of the *new-initializer* [[expr.new]].
+[*Example 1*:
+``` cpp
+struct S {
+  int m;
+};
+void f() {
+  S x{1};
+  new(&x) S(x.m);   // undefined behavior
+}
+```
+— *end example*]
 The lifetime of a reference begins when its initialization is complete.
 The lifetime of a reference ends as if it were a scalar object requiring
 storage.
 [*Note 1*:  [[class.base.init]] describes the lifetime of base and
 [*Note 4*: The correct behavior of a program often depends on the
 destructor being invoked for each object of class type. — *end note*]
 Before the lifetime of an object has started but after the storage which
+the object will occupy has been allocated[^7]
+or after the lifetime of an object has ended and before the storage
 which the object occupied is reused or released, any pointer that
 represents the address of the storage location where the object will be
 or was located may be used but only in limited ways. For an object under
 construction or destruction, see  [[class.cdtor]]. Otherwise, such a
 pointer refers to allocated storage [[basic.stc.dynamic.allocation]],
 and using the pointer as if the pointer were of type `void*` is
 well-defined. Indirection through such a pointer is permitted but the
 resulting lvalue may only be used in limited ways, as described below.
+The program has undefined behavior if
 - the pointer is used as the operand of a *delete-expression*,
 - the pointer is used to access a non-static data member or call a
   non-static member function of the object, or
 - the pointer is implicitly converted [[conv.ptr]] to a pointer to a
   cv `void`, or to pointer to cv `void` and subsequently to pointer to
   cv `char`, cv `unsigned char`, or cv `std::byte` [[cstddef.syn]], or
 - the pointer is used as the operand of a `dynamic_cast`
   [[expr.dynamic.cast]].
+[*Example 2*:
 ``` cpp
 #include <cstdlib>
 struct B {
 ```
 — *end example*]
 Similarly, before the lifetime of an object has started but after the
+storage which the object will occupy has been allocated or after the
 lifetime of an object has ended and before the storage which the object
 occupied is reused or released, any glvalue that refers to the original
 object may be used but only in limited ways. For an object under
 construction or destruction, see  [[class.cdtor]]. Otherwise, such a
 glvalue refers to allocated storage [[basic.stc.dynamic.allocation]],
 and using the properties of the glvalue that do not depend on its value
+is well-defined. The program has undefined behavior if
 - the glvalue is used to access the object, or
 - the glvalue is used to call a non-static member function of the
   object, or
 - the glvalue is bound to a reference to a virtual base class
   [[dcl.init.ref]], or
 - the glvalue is used as the operand of a `dynamic_cast`
   [[expr.dynamic.cast]] or as the operand of `typeid`.
+[*Note 5*: Therefore, undefined behavior results if an object that is
+being constructed in one thread is referenced from another thread
+without adequate synchronization. — *end note*]
+An object o₁ is *transparently replaceable* by an object o₂ if
 - the storage that o₂ occupies exactly overlays the storage that o₁
   occupied, and
 - o₁ and o₂ are of the same type (ignoring the top-level cv-qualifiers),
   and
   [[intro.object]], and
 - either o₁ and o₂ are both complete objects, or o₁ and o₂ are direct
   subobjects of objects p₁ and p₂, respectively, and p₁ is transparently
   replaceable by p₂.
+After the lifetime of an object has ended and before the storage which
+the object occupied is reused or released, if a new object is created at
+the storage location which the original object occupied and the original
+object was transparently replaceable by the new object, a pointer that
+pointed to the original object, a reference that referred to the
+original object, or the name of the original object will automatically
+refer to the new object and, once the lifetime of the new object has
+started, can be used to manipulate the new object.
+[*Example 3*:
 ``` cpp
 struct C {
   int i;
   void f();
 c1.f();                         // well-defined; c1 refers to a new object of type C
 ```
 — *end example*]
+[*Note 6*: If these conditions are not met, a pointer to the new object
 can be obtained from a pointer that represents the address of its
 storage by calling `std::launder` [[ptr.launder]]. — *end note*]
 If a program ends the lifetime of an object of type `T` with static
 [[basic.stc.static]], thread [[basic.stc.thread]], or automatic
 [[basic.stc.auto]] storage duration and if `T` has a non-trivial
+destructor,[^8]
 and another object of the original type does not occupy that same
 storage location when the implicit destructor call takes place, the
 behavior of the program is undefined. This is true even if the block is
 exited with an exception.
+[*Example 4*:
 ``` cpp
 class T { };
 struct B {
   ~B();
 Creating a new object within the storage that a const, complete object
 with static, thread, or automatic storage duration occupies, or within
 the storage that such a const object used to occupy before its lifetime
 ended, results in undefined behavior.
+[*Example 5*:
 ``` cpp
 struct B {
   B();
   ~B();
 }
 ```
 — *end example*]
+### Indeterminate and erroneous values <a id="basic.indet">[[basic.indet]]</a>
 When storage for an object with automatic or dynamic storage duration is
+obtained, the bytes comprising the storage for the object have the
+following initial value:
+- If the object has dynamic storage duration, or is the object
+  associated with a variable or function parameter whose first
+  declaration is marked with the `[[indeterminate]]` attribute
+  [[dcl.attr.indet]], the bytes have *indeterminate values*;
+- otherwise, the bytes have *erroneous values*, where each value is
+  determined by the implementation independently of the state of the
+  program.
+If no initialization is performed for an object (including subobjects),
+such a byte retains its initial value until that value is replaced
+[[dcl.init.general]], [[expr.assign]]. If any bit in the value
+representation has an indeterminate value, the object has an
+indeterminate value; otherwise, if any bit in the value representation
+has an erroneous value, the object has an erroneous value.
+[*Note 1*: Lvalue-to-rvalue conversion has undefined behavior if the
+erroneous value of an object is not valid for its type
+[[conv.lval]]. — *end note*]
+[*Note 2*: Objects with static or thread storage duration are
 zero-initialized, see  [[basic.start.static]]. — *end note*]
+Except in the following cases, if an indeterminate value is produced by
+an evaluation, the behavior is undefined, and if an erroneous value is
+produced by an evaluation, the behavior is erroneous and the result of
+the evaluation is the value so produced but is not erroneous:
+- If an indeterminate or erroneous value of unsigned ordinary character
+ type [[basic.fundamental]] or `std::byte` type [[cstddef.syn]] is
+ produced by the evaluation of:
   - the second or third operand of a conditional expression
     [[expr.cond]],
   - the right operand of a comma expression [[expr.comma]],
   - the operand of a cast or conversion
     [[conv.integral]], [[expr.type.conv]], [[expr.static.cast]], [[expr.cast]]
     to an unsigned ordinary character type or `std::byte` type
     [[cstddef.syn]], or
   - a discarded-value expression [[expr.context]],
+  then the result of the operation is an indeterminate value or that
+  erroneous value, respectively.
+- If an indeterminate or erroneous value of unsigned ordinary character
+ type or `std::byte` type is produced by the evaluation of the right
+ operand of a simple assignment operator [[expr.assign]] whose first
+ operand is an lvalue of unsigned ordinary character type or
+ `std::byte` type, an indeterminate value or that erroneous value,
+  respectively, replaces the value of the object referred to by the left
+ operand.
+- If an indeterminate or erroneous value of unsigned ordinary character
+ type is produced by the evaluation of the initialization expression
+  when initializing an object of unsigned ordinary character type, that
+  object is initialized to an indeterminate value or that erroneous
+  value, respectively.
 - If an indeterminate value of unsigned ordinary character type or
   `std::byte` type is produced by the evaluation of the initialization
   expression when initializing an object of `std::byte` type, that
+  object is initialized to an indeterminate value or that erroneous
+  value, respectively.
+Converting an indeterminate or erroneous value of unsigned ordinary
+character type or `std::byte` type produces an indeterminate or
+erroneous value, respectively. In the latter case, the result of the
+conversion is the value of the converted operand.
 [*Example 1*:
 ``` cpp
 int f(bool b) {
+  unsigned char *c = new unsigned char;
+  unsigned char d = *c; // OK, d has an indeterminate value
   int e = d;                    // undefined behavior
   return b ? d : 0;             // undefined behavior if b is true
 }
+int g(bool b) {
+  unsigned char c;
+  unsigned char d = c;          // no erroneous behavior, but d has an erroneous value
+  assert(c == d);               // holds, both integral promotions have erroneous behavior
+  int e = d;                    // erroneous behavior
+  return b ? d : 0;             // erroneous behavior if b is true
+}
+void h() {
+  int d1, d2;
+  int e1 = d1;                  // erroneous behavior
+  int e2 = d1;                  // erroneous behavior
+  assert(e1 == e2);             // holds
+  assert(e1 == d1);             // holds, erroneous behavior
+  assert(e2 == d1);             // holds, erroneous behavior
+  std::memcpy(&d2, &d1, sizeof(int));   // no erroneous behavior, but d2 has an erroneous value
+  assert(e1 == d2);             // holds, erroneous behavior
+  assert(e2 == d2);             // holds, erroneous behavior
+}
 ```
 — *end example*]
 ### Storage duration <a id="basic.stc">[[basic.stc]]</a>
 - static storage duration
 - thread storage duration
 - automatic storage duration
 - dynamic storage duration
+[*Note 1*: After the duration of a region of storage has ended, the use
+of pointers to that region of storage is limited
+[[basic.compound]]. — *end note*]
 Static, thread, and automatic storage durations are associated with
+objects introduced by declarations [[basic.def]] and with temporary
+objects [[class.temporary]]. The dynamic storage duration is associated
+with objects created by a *new-expression* [[expr.new]] or with
+implicitly created objects [[intro.object]].
 The storage duration categories apply to references as well.
+The storage duration of subobjects and reference members is that of
+their complete object [[intro.object]].
 #### Static storage duration <a id="basic.stc.static">[[basic.stc.static]]</a>
 All variables which
 [[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 scope and are not explicitly declared
+`static`, `thread_local`, or `extern` have *automatic storage duration*.
+The storage for such variables 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*]
+Variables that belong to a parameter scope also have automatic storage
+duration. The storage for a function parameter lasts until immediately
+after its destruction [[expr.call]].
 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.elision]].
 [[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 [[term.replaceable.function]]. The following
+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, 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;
 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.[^9]
 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:
 An allocation function that fails to allocate storage can invoke the
 currently installed new-handler function [[new.handler]], if any.
 [*Note 3*:  A program-supplied allocation function can obtain the
+currently installed `new_handler` using the `std::get_new_handler`
+function [[get.new.handler]]. — *end note*]
 An allocation function that has a non-throwing exception specification
 [[except.spec]] indicates failure by returning a null pointer value. Any
 other allocation function never returns a null pointer value and
 indicates failure only by throwing an exception [[except.throw]] of a
 [*Note 4*: 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]], for an object of type
+`std::contracts::contract_violation` when a contract violation occurs
+[[basic.contract.eval]], 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
 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`,[^10] 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.
 ### Temporary objects <a id="class.temporary">[[class.temporary]]</a>
+A *temporary object* is an object created
+- when a prvalue is converted to an xvalue [[conv.rval]] and
 - when needed by the implementation to pass or return an object of
+ suitable type (see below).
 Even when the creation of the temporary object is unevaluated
 [[expr.context]], all the semantic restrictions shall be respected as if
 the temporary object had been created and later destroyed.
+[*Note 1*: This includes accessibility [[class.access]] and whether it
 is deleted, for the constructor selected and for the destructor.
 However, in the special case of the operand of a *decltype-specifier*
 [[dcl.type.decltype]], no temporary is introduced, so the foregoing does
 not apply to such a prvalue. — *end note*]
 The materialization of a temporary object is generally delayed as long
 as possible in order to avoid creating unnecessary temporary objects.
+[*Note 2*:
 Temporary objects are materialized:
 - when binding a reference to a prvalue
   [[dcl.init.ref]], [[expr.type.conv]], [[expr.dynamic.cast]], [[expr.static.cast]], [[expr.const.cast]], [[expr.cast]],
+- when performing certain member accesses on a class prvalue
   [[expr.ref]], [[expr.mptr.oper]],
+- when invoking an implicit object member function on a class prvalue
+  [[expr.call]],
 - when performing an array-to-pointer conversion or subscripting on an
   array prvalue [[conv.array]], [[expr.sub]],
 - when initializing an object of type `std::initializer_list<T>` from a
   *braced-init-list* [[dcl.init.list]],
 - for certain unevaluated operands [[expr.typeid]], [[expr.sizeof]], and
 materialized so that the reference parameter of `X::operator=(const X&)`
 can bind to it.
 — *end example*]
+When an object of type `X` is passed to or returned from a
+potentially-evaluated function call, if `X` is
+- a scalar type or
+- a class type that has at least one eligible copy or move constructor
+  [[special]], where each such constructor is trivial, and the
+  destructor of `X` is either trivial or deleted,
+implementations are permitted to create temporary objects to hold the
+function parameter or result object, as follows:
+- The first such temporary object is constructed from the function
+  argument or return value, respectively.
+- Each successive temporary object is initialized from the previous one
+  as if by direct-initialization if `X` is a scalar type, otherwise by
+  using an eligible trivial constructor.
+- The function parameter or return object is initialized from the final
+  temporary as if by direct-initialization if `X` is a scalar type,
+  otherwise by using an eligible trivial constructor.
+(In all cases, the eligible constructor is used even if that constructor
+is inaccessible or would not be selected by overload resolution to
+perform a copy or move of the object).
+[*Note 3*: This latitude is granted to allow objects to be passed to or
+returned from functions in registers. — *end note*]
+Temporary objects are destroyed as the last step in evaluating the
+full-expression [[intro.execution]] that (lexically) contains the point
+where they were created. This is true even if that evaluation ends in
+throwing an exception. The value computations and side effects of
+destroying a temporary object are associated only with the
+full-expression, not with any specific subexpression.
+Temporary objects are destroyed at a different point than the end of the
+full-expression in the following contexts: The first context is when a
+default constructor is called to initialize an element of an array with
+no corresponding initializer [[dcl.init]]. The second context is when a
+copy constructor is called to copy an element of an array while the
+entire array is copied
 [[expr.prim.lambda.capture]], [[class.copy.ctor]]. In either case, if
 the constructor has one or more default arguments, the destruction of
 every temporary created in a default argument is sequenced before the
 construction of the next array element, if any.
+The third context is when a reference binds to a temporary object.[^11]
 The temporary object to which the reference is bound or the temporary
 object that is the complete object of a subobject to which the reference
 is bound persists for the lifetime of the reference if the glvalue to
 which the reference is bound was obtained through one of the following:
                                             // exactly one of the two temporaries is lifetime-extended
 ```
 — *end example*]
+[*Note 4*:
 An explicit type conversion [[expr.type.conv]], [[expr.cast]] is
 interpreted as a sequence of elementary casts, covered above.
 [*Example 3*:
 — *end example*]
 — *end note*]
+[*Note 5*:
 If a temporary object has a reference member initialized by another
 temporary object, lifetime extension applies recursively to such a
 member’s initializer.
   containing the call.
 - A temporary object bound to a reference element of an aggregate of
   class type initialized from a parenthesized *expression-list*
   [[dcl.init]] persists until the completion of the full-expression
   containing the *expression-list*.
 - A temporary bound to a reference in a *new-initializer* [[expr.new]]
   persists until the completion of the full-expression containing the
   *new-initializer*.
+  \[*Note 6*: This might introduce a dangling reference. — *end note*]
   \[*Example 5*:
   ``` cpp
   struct S { int mi; const std::pair<int,int>& mp; };
   S a { 1, {2,3} };
   S* p = new S{ 1, {2,3} };       // creates dangling reference
   ```
   — *end example*]
+The fourth context is when a temporary object is created in the
+*for-range-initializer* of either a range-based `for` statement or an
+enumerating expansion statement [[stmt.expand]]. If such a temporary
+object would otherwise be destroyed at the end of the
+*for-range-initializer* full-expression, the object persists for the
+lifetime of the reference initialized by the *for-range-initializer*.
+The fifth context is when a temporary object is created in the
+*expansion-initializer* of an iterating or destructuring expansion
+statement. If such a temporary object would otherwise be destroyed at
+the end of that *expansion-initializer*, the object persists for the
+lifetime of the reference initialized by the *expansion-initializer*, if
+any.
+The sixth context is when a temporary object is created in a structured
+binding declaration [[dcl.struct.bind]]. Any temporary objects
+introduced by the *initializer*s for the variables with unique names are
+destroyed at the end of the structured binding declaration.
+Let `x` and `y` each be either a temporary object whose lifetime is not
+extended, or a function parameter. If the lifetimes of `x` and `y` end
+at the end of the same full-expression, and `x` is initialized before
+`y`, then the destruction of `y` is sequenced before that of `x`. If the
+lifetime of two or more temporaries with lifetimes extending beyond the
+full-expressions in which they were created ends at the same point,
+these temporaries are destroyed at that point in the reverse order of
+the completion of their construction. In addition, the destruction of
+such temporaries shall take into account the ordering of destruction of
+objects with static, thread, or automatic storage duration
 [[basic.stc.static]], [[basic.stc.thread]], [[basic.stc.auto]]; that is,
 if `obj1` is an object with the same storage duration as the temporary
 and created before the temporary is created the temporary shall be
 destroyed before `obj1` is destroyed; if `obj2` is an object with the
 same storage duration as the temporary and created after the temporary

Diff to HTML by rtfpessoa