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

Files changed (1) hide show

tmp/tmp6g2ds0js/{from.md → to.md} +52 -30

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

@@ -1,12 +1,17 @@
 ### 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]],
@@ -21,10 +26,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
@@ -53,22 +77,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
@@ -78,11 +102,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 {
@@ -111,36 +135,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
@@ -149,11 +169,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();
@@ -175,25 +204,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();
@@ -210,11 +239,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();
@@ -228,12 +257,5 @@ 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*]

 ### 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*]

Diff to HTML by rtfpessoa