[intro.object] - C++23 → Trunk

Files changed (1) hide show

tmp/tmpsqrccbx5/{from.md → to.md} +45 -20

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

@@ -27,21 +27,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*.
@@ -51,10 +51,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() {
@@ -65,20 +67,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*.
@@ -119,23 +121,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
@@ -144,16 +168,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*]
@@ -186,20 +210,21 @@ 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*]

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

Diff to HTML by rtfpessoa