6 Basics [basic]

6.7 Memory and objects [basic.memobj]

6.7.2 Object model [intro.object]

The constructs in a C++ program create, destroy, refer to, access, and manipulate objects.

An object is created by a definition, by a new-expression ([expr.new]), by an operation that implicitly creates objects (see below), when implicitly changing the active member of a 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, 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 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:

(2.1)
the lifetime of e's containing object has begun and not ended, and
(2.2)
the storage for the new object exactly overlays the storage location associated with e, and
(2.3)
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:

(3.1)
the lifetime of e has begun and not ended, and
(3.2)
the storage for the new object fits entirely within e, and
(3.3)
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: // assumes that sizeof(int) is equal to 4 template<typename ...T> struct AlignedUnion { alignas(T...) unsigned char data[max(sizeof(T)...)]; }; int f() { AlignedUnion<int, char> au; int *p = new (au.data) int; // OK, au.data provides storage char *c = new (au.data) char(); // OK, ends lifetime of *p char *d = new (au.data + 1) char(); 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:

(4.1)
a is a subobject of b, or
(4.2)
b provides storage for a, or
(4.3)
there exists an object c where a is nested within c, and c is nested within b.

For every object x, there is some object called the complete object of x, determined as follows:

(5.1)
If x is a complete object, then the complete object of x is itself.
(5.2)
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:

(7.1)
a base class subobject, or
(7.2)
a non-static data member declared with the no_unique_address attribute.

An object has nonzero size if it

(8.1)
is not a potentially-overlapping subobject, or
(8.2)
is not of class type, or
(8.3)
is of a class type with virtual member functions or virtual base classes, or
(8.4)
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, 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.

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

(10.1)
one is nested within the other,
(10.2)
at least one is a subobject of zero size and they are not of similar types ([conv.qual]), or
(10.3)
they are both potentially non-unique objects;

otherwise, they have distinct addresses and occupy disjoint bytes of storage.21

[Example 2: 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 an unspecified byte of storage occupied by the complete object of that 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]

Further, after implicitly creating objects within a specified region of storage, some operations are described as producing a pointer to a suitable created object.

These operations select one of the implicitly-created objects whose address is the address of the start of the region of storage, and produce a pointer value that points to that object, if that value would result in the program having defined behavior.

If no such pointer value would give the program defined behavior, the behavior of the program is undefined.

If multiple such pointer values would give the program defined behavior, it is unspecified which such pointer value is produced.

[Example 3: #include <cstdlib> struct X { int a, b; }; X *make_x() { // The call to std::malloc implicitly creates an object of type X // and its subobjects a and b, and returns a pointer to that X object // (or an object that is pointer-interconvertible ([basic.compound]) with it), // in order to give the subsequent class member access operations // defined behavior. X *p = (X*)std::malloc(sizeof(struct X)); p->a = 1; p->b = 2; return p; } — 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], [c.malloc], [mem.res.public], [bit.cast], [cstring.syn]).

— end note]

21)21)

Under the “as-if” rule an implementation is allowed to store two objects at the same machine address or not store an object at all if the program cannot observe the difference ([intro.execution]).