This seems strange. std::launder explicitly says it cannot convert a pointer to 'o1' to a pointer to 'o2' unless 'o1' and 'o2' are pointer interconvertible, otherwise it is UB.

from my understanding, I thought that std::launder was only an escape hatch for dealing with stale references to non transparently replaceable objects.

On August 6, 2023 1:20:00 p.m. EDT, Mykola Garkusha via Std-Discussion <std-discussion@lists.isocpp.org> wrote:

Thanks, this is super clear actually. Everything settled after deep diving into pointer conversions for non-pointer-interconvertible objects.

So then with std::launder, this shall work as it should return pointer value "pointer to T"?

T2* ptr2 = std::laudner(reinterpret_cast<T2 *>(&storage_)) 

ptr2->value... 

On Sun, Aug 6, 2023 at 5:39 PM Matthew House via Std-Discussion <std-discussion@lists.isocpp.org> wrote:

On Sun, Aug 6, 2023 at 10:03 AM Mykola Garkusha
<garkusha.mykola@gmail.com> wrote:
> Just want to clarify this clearly to be 100% sure.
>
> > Not in general; [basic.lval] para. 11 is specifically about reading
> > and writing scalar values through a glvalue, and nothing else. Since
> > ptr2 is a T* pointer pointing to an std::byte object, you can't do
> > most things with ptr2 that you could do with an arbitrary T* pointer,
>
> ptr2 should point to T2 now
>
> https://eel.is/c++draft/expr#reinterpret.cast-7
> https://eel.is/c++draft/expr#reinterpret.cast-3

That's not how it works in this case, since the two objects 'storage_'
and '*ptr_' are not pointer-interconvertible. By
[expr.reinterpret.cast] para. 7, 'T* ptr2 =
reinterpret_cast<T*>(&storage_)' is equivalent to 'T* ptr2 =
static_cast<T*>(static_cast<void*>(&storage_))'. Here, '&storage_'
points to the entire 'storage_' array (not to its first element
'storage_[0]', as I mistakenly said earlier), so by [expr.static.cast]
para. 4 and [conv.ptr] para. 2, 'static_cast<void*>(&storage_)' also
points to the 'storage_' array.

For 'T* ptr2 = static_cast<T*>(...)', we have to look at
[expr.static.cast] para. 14: *if* there exists an object of type
(similar to) T pointer-interconvertible with 'storage_', then 'ptr2'
will point to that T object; *otherwise*, 'ptr2' will be a T* pointer
pointing to the 'storage_' array. But if we look at the definition of
pointer-interconvertible objects in [basic.compound] para. 4, none of
those bullets apply for 'storage_' and '*ptr_': they are different
objects, neither is a union object, and neither is the first
non-static member of the other. Therefore, 'ptr2' is a T* pointer
pointing to the std::byte[sizeof(T)] array 'storage_', not a T*
pointer pointing to the T object '*ptr_'.

> Not sure how strict aliasing (https://eel.is/c++draft/expr#basic.lval-11) can be violated in the example below, as the access (for scalar variables) would be done through dynamic type, as T2 lifetime has started and storage_ provides storage for it.
> T2* ptr2 = reinterpret_cast<T2 *>(&storage_)
> ptr2->value/*scalar*/;
>
> > ([expr.ref] para. 8). Most (but not all) usual
> > operations require that the dynamic type of the pointee actually
> > matches the type of the pointer.
>
> I don't see how the above violates the sample below.
>  reinterpret_cast<T2 *>(&storage_)->....

Look at [expr.ref] para. 8. The class member access 'ptr2->value' is
illegal, regardless of what is done with that glvalue afterwards. The
"strict aliasing" rule in [basic.lval] para. 11 only applies *after*
that class member access is done, and even then it helps only if
'value' is a char, unsigned char, or std::byte.

> The type of expression above is T* and that is what the *actual* result of reintepret_cast is as T2's object address should be equal to the address of storage_ and storage_ provides storage for T2's object which is in turn tested within storage_. Although I agree that std::launder would make it more explicit and I can be wrong on this. https://eel.is/c++draft/basic#intro.object-9

The std::byte[sizeof(T)] array does provide storage for the T object,
but this is irrelevant here, since the array object and the T object
are not pointer-interconvertible. The only importance of providing
storage is that the T object is nested within the array by
([intro.object] para. 4), so constructing the T object doesn't end the
lifetime of the array ([basic.life] para. 1).
--
Std-Discussion mailing list
Std-Discussion@lists.isocpp.org
https://lists.isocpp.org/mailman/listinfo.cgi/std-discussion

--
Std-Discussion mailing list
Std-Discussion@lists.isocpp.org
https://lists.isocpp.org/mailman/listinfo.cgi/std-discussion