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

Files changed (1) hide show

tmp/tmp4cvryknk/{from.md → to.md} +31 -29

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

@@ -3,27 +3,27 @@
 The constructs in a C++ program create, destroy, refer to, access, and
 manipulate objects. An *object* is created by a definition
 [[basic.def]], by a *new-expression* [[expr.new]], by an operation that
 implicitly creates objects (see below), when implicitly changing the
 active member of a union [[class.union]], or when a temporary object is
-created ([[conv.rval]], [[class.temporary]]). An object occupies a
-region of storage in its period of construction [[class.cdtor]],
-throughout its lifetime [[basic.life]], and in its period of destruction
 [[class.cdtor]].
 [*Note 1*: A function is not an object, regardless of whether or not it
 occupies storage in the way that objects do. — *end note*]
 The properties of an object are determined when the object is created.
 An object can have a name [[basic.pre]]. An object has a storage
 duration [[basic.stc]] which influences its lifetime [[basic.life]]. An
-object has a type [[basic.types]]. Some objects are polymorphic
-[[class.virtual]]; the implementation generates information associated
-with each such object that makes it possible to determine that object’s
-type during program execution. For other objects, the interpretation of
-the values found therein is determined by the type of the *expression*s
-[[expr.compound]] used to access them.
 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
@@ -41,13 +41,14 @@ 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 smaller array object that satisfies these constraints.
-[*Note 2*: If that portion of the array previously provided storage for
 another object, the lifetime of that object ends because its storage was
 reused [[basic.life]]. — *end note*]
 [*Example 1*:
@@ -88,12 +89,12 @@ of* `x`, determined as follows:
 - If `x` is a complete object, then the complete object of `x` is
   itself.
 - Otherwise, the complete object of `x` is the complete object of the
   (unique) object that contains `x`.
-If a complete object, a data member [[class.mem]], or an array element
-is of class type, its type is considered the *most derived class*, to
 distinguish it from the class type of any base class subobject; an
 object of a most derived class type or of a non-class type is called a
 *most derived object*.
 A *potentially-overlapping subobject* is either:
@@ -106,27 +107,28 @@ An object has nonzero size if it
 - is not a potentially-overlapping subobject, or
 - is not of class type, or
 - is of a class type with virtual member functions or virtual base
   classes, or
-- has subobjects of nonzero size or bit-fields of nonzero length.
 Otherwise, if the object is a base class subobject of a standard-layout
 class type with no non-static data members, it has zero size. Otherwise,
 the circumstances under which the object has zero size are
 *implementation-defined*. Unless it is a bit-field [[class.bit]], an
 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]] 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.[^10]
 [*Example 2*:
 ``` cpp
 static const char test1 = 'x';
@@ -142,18 +144,18 @@ 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]] 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 3*: Such operations do not start the lifetimes of subobjects of
 such objects that are not themselves of implicit-lifetime
 types. — *end note*]
 Further, after implicitly creating objects within a specified region of
 storage, some operations are described as producing a pointer to a
@@ -184,20 +186,20 @@ X *make_x() {
 }
 ```
 — *end example*]
-An operation that begins the lifetime of an array of `char`,
-`unsigned char`, or `std::byte` implicitly creates objects within the
-region of storage occupied by the array.
-[*Note 4*: 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 5*: Some functions in the C++ standard library implicitly create
-objects ([[allocator.traits.members]], [[c.malloc]], [[cstring.syn]],
-[[bit.cast]]). — *end note*]

 The constructs in a C++ program create, destroy, refer to, access, and
 manipulate objects. An *object* is created by a definition
 [[basic.def]], by a *new-expression* [[expr.new]], by an operation that
 implicitly creates objects (see below), when implicitly changing the
 active member of a union [[class.union]], or when a temporary object is
+created [[conv.rval]], [[class.temporary]]. An object occupies a region
+of storage in its period of construction [[class.cdtor]], throughout its
+lifetime [[basic.life]], and in its period of destruction
 [[class.cdtor]].
 [*Note 1*: A function is not an object, regardless of whether or not it
 occupies storage in the way that objects do. — *end note*]
 The properties of an object are determined when the object is created.
 An object can have a name [[basic.pre]]. An object has a storage
 duration [[basic.stc]] which influences its lifetime [[basic.life]]. An
+object has a type [[basic.types]].
+[*Note 2*: Some objects are polymorphic [[class.virtual]]; the
+implementation generates information associated with each such object
+that makes it possible to determine that object’s type during program
+execution. — *end note*]
 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
 “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*.
+[*Note 3*: If that portion of the array previously provided storage for
 another object, the lifetime of that object ends because its storage was
 reused [[basic.life]]. — *end note*]
 [*Example 1*:
 - If `x` is a complete object, then the complete object of `x` is
   itself.
 - Otherwise, the complete object of `x` is the complete object of the
   (unique) object that contains `x`.
+If a complete object, a member subobject, or an array element is of
+class type, its type is considered the *most derived class*, to
 distinguish it from the class type of any base class subobject; an
 object of a most derived class type or of a non-class type is called a
 *most derived object*.
 A *potentially-overlapping subobject* is either:
 - is not a potentially-overlapping subobject, or
 - is not of class type, or
 - is of a class type with virtual member functions or virtual base
   classes, or
+- has subobjects of nonzero size or unnamed bit-fields of nonzero
+  length.
 Otherwise, if the object is a base class subobject of a standard-layout
 class type with no non-static data members, it has zero size. Otherwise,
 the circumstances under which the object has zero size are
 *implementation-defined*. Unless it is a bit-field [[class.bit]], an
 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';
 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*]
 Further, after implicitly creating objects within a specified region of
 storage, some operations are described as producing a pointer to a
 }
 ```
 — *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*]

Diff to HTML by rtfpessoa