C++, reinterpret_cast and const*: how portable is this code?

Question

C++ / C#

"Bicycle" associated with a variable length array.

template <class Elem>
struct Buf1d
{
    size_t _size;
    Elem* _ptr;

    operator const Buf1d<const Elem>&() const
        { return reinterpret_cast<Buf1d<const Elem>&>(*this); }
}

As if no problems and two structures, { size_t _size; int*_ptr; } and {size_t size; const int*_ptr; } inside are guaranteed to be the same, because POD's. Am I right or wrong?
PS There are no other fields, there is no virtual, only methods that are not relevant, like operator[], have been removed.

Answer 1

1. adding const to Buf1d<const Elem> does not turn { size_t _size; int*_ptr; } to { size_t _size; const int*_ptr; }, at best, in { const size_t _size; int*const_ptr; }
2. const T and T according to C++98 3.9.3:1 are represented the same and have the same alignment.
3. const T *p and T *p according to the same standard, 3.9.2:3 also have the same representation and alignment.
Conclusion: you did not get what you expected, but it is correct and portable.