Is creating an object not the same thing as starting its lifetime?

Based on the comment by @LanguageLawyer:

My understanding as explained in the question is mostly correct, but "created" isn't the right word for this, as it apparently means something else (something similar to starting the lifetime as @Caleb says in his answer).

So yes, beginning a lifetime¹ of an object always recursively causes all its member (sub)objects to begin existing. "Existing" not necessarily in the sense of having their lifetime started, but in the wider sense of being considered "objects" (possibly outside of their lifetime).

(¹ Or more correctly, this happens even before the lifetime starts, since e.g. class data members already exist while its constructor runs (and its lifetime only starts when the constructor finishes). So apparently "creating" an object means beginning the process that will start its lifetime, and creating an object recursively causes all its members to begin existing.)

E.g. when an array begins its lifetime but its elements don't (e.g. as returned by std::allocator::allocate()), its elements are still considered to be "objects", since an array by definition contains a bunch of objects (regardless of their lifetime):

[dcl.array]/6

An object of type “array of N U” consists of a contiguously allocated non-empty set of N subobjects of type U, known as the elements of the array...

Similarly all member objects of a union always exist, even inactive ones, though at most one of them can be within its lifetime at the same time.

starting object's lifetime recursively creates all its subobjects

This used to be the case¹; only because there was no method to create an object but not its sub-objects. Your example of std::allocator::allocate is now one counterexample to that.

In general, the process of creating an object has some duration. The object's lifetime starts once that process is complete.

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]),

[basic.life#2]

So in that sense, "creating an object" is not the quite the same as "starting its lifetime", as that happens instantaneously at the end of the initialization. But that doesn't seem to be the confusion that your colleague has.

Further along in [basic.life#8], the standard is fairly precise in identifying values that correspond to a future (or past) object, i.e. the storage that will (or did) contain a particular object, outside that object's lifetime. It does still refer to the object, so there is still the notion of an object, even outside its lifetime. Importantly, within a constructor or destructor, this points to such an object.

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.

¹ Arguably it was never the case, because even at that time std::vector had to be able to transmute an array of one size into an array of another size whilst maintaining the lifetime of the sub-objects shared by the two arrays.

I am not entirely sure if this answers your question in full, but here is some information to consider:

Both array and union are merely "managerial". They provide safety and structure, without actually caring much about their contents. They allocate the space needed to perform their duties, but the way they create their content is maybe not the most intuitive way. The closest to that is initializing it with default values.

An object is created by a definition, by a new-expression, 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]) [1]

If you have a simple std::array<int, n> numbers, then the array-object is created and it will allocate enough space to store n integers. Since these are arithmetic types, they will be set to 0 by default. Thus you could say the integer objects are created.

If you have std::array<SomePointerTypeObject, n> objects, then the array will still allocate space for n pointers, however all of them will be set to default nullptr. If you consider nullptr to be an object is another thing, but since it handles like any other pointer, i would argue by creating the array objects, you linked to the nullptr "object". Since it is a constant, it is not "created", but has been "created" at its time of definition.

Since union-objects behave similarly with their first named member, they are the same for this argument.

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]). [1]

Hope this helps, or at least brings information as a basis for further discussion.

[1] : https://timsong-cpp.github.io/cppwp/n4861/intro.object#1