On Fri, Apr 10, 2020 at 10:28 PM Tadeus Prastowo via Std-Discussion <
std-discussion_at_[hidden]> wrote:
>>
>> Inspired by: https://teratail.com/questions/250362 and
>> https://stackoverflow.com/questions/56977042/reusing-objects-space-by-another-object.
>>
>> At the beginning of [basic.life]/6
>> <https://timsong-cpp.github.io/cppwp/n4659/basic.life#6>, the following was written:
>>
>> 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 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.
>>
>> However, the example in [basic.life]/6 also describes a pointer to the
>> storage which the new object was created.

> Could you copy and paste the example, please?

Thank you for your reply. Here is an example.

[ Example: 
#include <cstdlib>

struct B {
  virtual void f();
  void mutate();
  virtual ~B();
};

struct D1 : B { void f(); };
struct D2 : B { void f(); };

void B::mutate() {
  new (this) D2;    // reuses storage — ends the lifetime of *this
  f();              // undefined behavior
  ... = this;       // OK, this points to valid memory
}

void g() {
  void* p = std::malloc(sizeof(D1) + sizeof(D2));
  B* pb = new (p) D1;
  pb->mutate();
  *pb;              // OK: pb points to valid memory
  void* q = pb;     // OK: pb points to valid memory
  pb->f();          // undefined behavior, lifetime of *pb has ended
}
 — end example ]

>> Does the description of [basic.life]/6, especially the description after the
>> "otherwise" clause, also say a pointer to the storage which another new object was created?
>>
>> Furthermore, does (a) to (f) in the following code cause undefined behavior?
>>
>> #include <cstdint>
>> #include <new>
>>
>> int main()
>> {
>>     std::uint32_t* p32 = new std::uint32_t[4]{};

> At this point, the four objects of type std::uint32_t have already
> been alive due to the use of `{}'.

>>     std::uint16_t* p16 = new (p32) std::uint16_t[4]{};

> At this point, the four objects of type std::uint32_t have ended their
> lives due to storage reuse.
> And, the four objects of type std::uint16_t have already been alive
> due to the use of `{}'.

>>     *p32;  // (a) (indirect references of type void* are not allowed)

> UB because the four objects of type std::uint32_t have ended their
> lives due to storage reuse.

In the [basic.life]/6 example, I do not know why `*pb` is not UB.

>>     std::uint32_t lval = *p32 + 100;  // (b)

> UB due to `*p32' for the reason given above.

>>     std::uint32_t* p32_2 = p32 + 2;  // (c)

> This is okay because p32 is a valid pointer.

>>     *p32_2 = 0;  // (d)

> UB for the same reason `*p32' is UB.

>>     p32 = new (p32) std::uint32_t[4];  // (e)

> At this point, the four objects of type std::uint16_t have ended their
> lives due to storage reuse.
> The four objects of type std::uint32_t, however, have not been
> constructed due to missing `{}'.

>>     delete [] p32;  // (f)

> This deallocates the storage.  Not UB because std::uint32_t has no
> non-trivial destructor.

>> }
>>
>> Thank you.

--
Best regards,
merukun1125