«

On 07.01.2013 10:16, Bart van Ingen Schenau wrote:
> The results of this program are not defined by the C++ language. By using
> reinterpret_cast and dereferencing the result, you have placed yourself
> completely at the mercy of the implementation.
>
> Although they are unlikely to take advantage of it, an implementation is
> allowed to put padding between the A and B members of segment, which
> would cause your code to fail.

In fact he expected that segment and vec share a binary compatible
memory layout. This is not guaranteed.

But what about

struct segment {
vec v[2];
};

or optionally

struct segment {
vec v[2];
vec& A() { return v[0]; }
vec& B() { return v[1]; }
};

I think this should be safe since the cast now goes to an array slice.


Marcel

On 2013-01-06 23:39, Ian Collins wrote:
> wrote:
>
> Please wrap your lines!
>
>> First thank you for your answer, but you misunderstood me.
>>
>> I do know that my example will compile with any compiler.
>>
>> I wanted to know, if this mini programm does work exactly the same
>> (with the same outputs), when I compile it with different compilers.
>
> As posted, it won't compile with any compiler.
>
> As I said in my reply (that you forgot to quote), all reinterpret_cast
> does is tell the compiler to interpret a bunch of bits as a particular
> type.
We can assume that everybody knows that.

> If the data pointed to happens to be of a compatible type and
> alignment, it will probably work. If not, it won't.
>
Question should be if there is guarantee that data placement is done in
the same way among different compilers. If not reinterpret_cast is not
portable at all.

Regards

Marek