3

Consider

struct full
{
    struct basic
    {
        int a = 1;
    } base;
    int b = 2;
};

void example()
{
    alignas(full) std::byte storage[/* plenty of storage */];
    full * pf = new (storage) full;
    basic * pb = &pf->base;

    new (storage) basic; // supposedly ends ​lifetime of *pf (right?)
    // if doesn't, suppose we did pf->~full(); before this line

    pb->a; // is this legal?

    new (storage) full; // supposedly ends ​lifetime of *pb (right?)
    // if doesn't, suppose we did pb->~basic(); before this line

    pb->a; // is this still legal?
    pf->b; // is this legal?
    pf->base.a; // is this legal?
}

I would like to know if any of the above is legal or not, including understanding whether the destructor call is necessary before each step.

Braiam
  • 1
  • 11
  • 47
  • 78
CppNerd13373
  • 53
  • 4

2 Answers2

1

The way it is written, your code has undefined behavior because both pf and pb stop pointing to an object as soon as it is destroyed (i.e. at the point of new (storage) basic;). In practical terms, the compiler is free to speculate the values that are accessible through these pointers across the new (storage) basic; expression. For example, reading through these pointers could produce values that the compiler speculated based on the previous writes through these pointers, but not necessarily through pointers to the newly constructed object.

The standard has std::launder function to mitigate this. The function effectively acts as a barrier for compiler speculations based on the pointer and the object it points to. Basically, it "erases" any knowledge the compiler might have had about the pointed object, and returns a pointer that was as if obtained anew. The corrected code would look like this:

void example()
{
    alignas(full) std::byte storage[/* plenty of storage */];
    full * pf = new (storage) full;
    basic * pb = &pf->base;

    new (storage) basic;

    pb = std::launder(pb); // prevent speculation about the object pb points to
    pb->a; // ok now

    new (storage) full;

    pf = std::launder(pf); // prevent speculation about pf and pb
    pb = std::launder(pb);

    // These are ok now
    pb->a;
    pf->b;
    pf->base.a;
}
Andrey Semashev
  • 10,046
  • 1
  • 17
  • 27
  • 1
    21.6.4.4 [ptr.launder] states `If a new object is created in storage occupied by an existing object of the same type, a pointer to the original object can be used to refer to the new object` so if the replaced struct does not contain any consts `launder` should not be necessary (though I'd say it's a good practice to use it). – alagner Oct 14 '21 at 22:26
0

21.6.4 [ptr.launder] states

  1. Note: If a new object is created in storage occupied by an existing object of the same type, a pointer to the original object can be used to refer to the new object unless the type contains const or reference members; in the latter cases, this function can be used to obtain a usable pointer to the new object.

...so generally it's a good practice to use launder it in case the struct contains consts or references. But I believe that in the following example:

    alignas(full) std::byte storage[/* plenty of storage */];
    full * pf = new (storage) full;
    basic * pb = &pf->base;
    new (storage) basic; // supposedly ends ​lifetime of *pf (right?)
    pb->a; // is this legal?

pb->a; is legal, i.e. it's NOT and UB provided the struct pointed to does not contain const members, neither does it contain references. So using launder here is a good practice, true. But it's not mandatory given the aforementioned conditions are met.

alagner
  • 3,448
  • 1
  • 13
  • 25
  • It says though "of the same type" and `basic` != `full`, are you sure that it's still not UB? – CppNerd13373 Oct 14 '21 at 22:55
  • I'd say so especially in this case: as those pointers should be [interconvertible](http://eel.is/c++draft/class#mem.general-note-12). If you can point me to a better place in the standard, I'll be happy to learn it :) – alagner Oct 14 '21 at 23:49
  • For a more generał case though I need to look it up in the standard. – alagner Oct 14 '21 at 23:57
  • I know they are interconvertible and that's exactly why I'm asking, the standard says same type and I wonder about this exactly since it is not clear whether it falls in this category of not needing the launder. – CppNerd13373 Oct 15 '21 at 00:12
  • IMO it does not need laundering, especially that [this part](https://timsong-cpp.github.io/cppwp/class.mem#general-27) states it's supposed to be the same address (provided standard layout). – alagner Oct 15 '21 at 10:35