ody>
> Is there a guarantee that a cast of a pointer does not change its representation and size?

Not much, but would this really matter? I can think of some required guaranties that relate pointer values in conversions, but they don't directly specify the exact details of the representation of pointers.

One guarantee is the roundtrip from a T* to a void*, and then convert back to T* will be identical to the original T* value.
In more details, the conversions are:
1) implicit or explicit (only with static_cast or C-style cast possibly in functional notation) conversion of a T* value v1 to a void* value v2.
2) explicit (only with static_cast or C-style cast possibly in functional notation) conversion of the void* value v2 to a T* value v3

Then it is guaranteed that v1 == v3, and both hold the same value in its object representation. However, whether v1 holds the same value representation as v2 is pretty much irrelevant because there is no way to observe if the value did change through conversion in the first step: if you try to compare v2 with some pointer value v4 representing the address in v1, then either v4 is already a void* converted from v1 or it is a T* that will convert to a void* at the time `v1 == v4` is performed (pointer comparisons operators requires operands of the same pointer type); in either cases, you only observe that the program produced identical void pointers out of identical pointer to T, and not if and how the conversion was performed. This doesn't answer if pointer to object types must have the same size though.

The 2 steps conversion sequence explained above is not of a pure academic interest: it is exactly the "identity pointer to same pointer type reinterpret_cast", ie
`T* v3 = reinterpret_cast<T*>(v1)`. It is a special case of the more general "T1* to T2* reinterpret_cast" which does the exact same steps but uses T2* as the target type in the second conversion. An important fact regarding the T1* to T2* reinterpret cast is that the pointer value it produces is only very seldomly usable without inducing UB (this only works in case there exists pointer-interconvertible objects with of the right types at that address). Roundtrip conversion from T1* to T2*, then T2* to T1* with reinterpret_cast will work if both types have same alignment requirements, otherwise I think it is implementation defined.


On January 27, 2025 2:32:50 a.m. EST, Sebastian Wittmeier via Std-Proposals <std-proposals_at_[hidden]> wrote:
>Is there a guarantee that a cast of a pointer does not change its representation and size?
>
>-----Ursprüngliche Nachricht-----
>Von:Gašper Ažman via Std-Proposals <std-proposals_at_[hidden]>
>Gesendet:Mo 27.01.2025 02:34
>Betreff:Re: [std-proposals] Make all data pointers intercompatible
>An:std-proposals_at_[hidden];
>CC:Gašper Ažman <gasper.azman_at_[hidden]>;
>
>You know all pointers are the same size because they're all static_cast-able to void* and back.
>
>On Mon, Jan 27, 2025 at 9:12 AM Jeremy Rifkin via Std-Proposals <std-proposals_at_[hidden] <mailto:std-proposals_at_[hidden]> > wrote:
>> It's possible if the compiler hides it from the programmer. For instance if CHAR_BIT==8, and if the CPU instructions deal with 16-Bit operands, then you can have:
> >
>> CHAR_BIT == 8
> > sizeof(int*) == 2
>> sizeof(char*) == 3
> All the language cares about is that you can in fact address every byte of memory. From a language perspective, if CHAR_BIT == 8 then the smallest addressable unit of memory is 8 bits irrespective of hardware details.
> Between https://eel.is/c++draft/basic.memobj#intro.memory-1 and https://eel.is/c++draft/basic.compound#7 and the fact struct Frog; Frog* ptr1 = nullptr; Frog* foo(); Frog* ptr2 = foo(); has to work I think it's sufficiently covered by the standard that all pointers to non-fundamental objects are the same size (or at least compatible in some way to make everything here work). Even if you had a system where sizeof(char*) == 3 and sizeof(int*) == 2 you would know sizeof(void*) >= 3.
> Cheers,
>Jeremy
>
>On Sun, Jan 26, 2025 at 5:42 PM Frederick Virchanza Gotham via Std-Proposals <std-proposals_at_[hidden] <mailto:std-proposals_at_[hidden]> > wrote:
>On Sun, Jan 26, 2025 at 11:17 PM Jeremy Rifkin wrote:
> >
> > > For example on a system where CHAR_BIT==8 but the smallest addressable unit of memory is 16 bits
> >
> > That's not possible https://eel.is/c++draft/basic.memobj#intro.memory-1
>
>
> It's possible if the compiler hides it from the programmer. For
> instance if CHAR_BIT==8, and if the CPU instructions deal with 16-Bit
> operands, then you can have:
>
> CHAR_BIT == 8
> sizeof(int*) == 2
> sizeof(char*) == 3
>
> An int* is a 16-Bit number representing a memory address.
> A char* is a 16-Bit number representing a memory address, with an
> extra byte to indicate the offset.
> --
> Std-Proposals mailing list
> Std-Proposals_at_[hidden] <mailto:Std-Proposals_at_[hidden]>
> https://lists.isocpp.org/mailman/listinfo.cgi/std-proposals
>
> --
> Std-Proposals mailing list
> Std-Proposals_at_[hidden] <mailto:Std-Proposals_at_[hidden]>
> https://lists.isocpp.org/mailman/listinfo.cgi/std-proposals
>
>
>
>
>--
> Std-Proposals mailing list
> Std-Proposals_at_[hidden]
> https://lists.isocpp.org/mailman/listinfo.cgi/std-proposals
>
>
>