casting structure pointer to union pointer in C++ - c++

Question

I have a Union containing various struct member.
union U {
struct S1 as_s1;
struct S2 as_s2;
…
};
How can I cast pointer to struct as_s1 to a pointer to union U in C++?
I know because of this that it can be easily done using C casting. But I want to use the feature of Advance class type casting of C++ without causing any errors.

Answer 1

From the standard 6.9.2.4.
Two objects a and b are pointer-interconvertible if:
they are the same object, or
one is a standard-layout union object and the other is a non-static data member of that object (12.3),
one is a standard-layout class object and the other is the first non-static data member of that object, or, if the object has no non-static data members, the first base class subobject of that object (12.2), or
there exists an object c such that a and c are pointer-interconvertible, and c and b are pointer-interconvertible.
If two objects are pointer-interconvertible, then they have the same address, and it is possible to obtain a pointer to one from a pointer to the other via a reinterpret_cast (8.2.10).
This means that you can convert them to each other using reinterpret_cast. However, you cannot access the memory of wrong type. E.g., following is a well-defined code:
#include <iostream>
struct S1 {
int i;
};
struct S2 {
short int i;
};
union U {
struct S1 as_s1;
struct S2 as_s2;
};
void printUnion(U* u, int type) {
if (type == 0){
S1 *s1 = reinterpret_cast<S1*>(u);
std::cout << s1->i << std::endl;
} else {
S2 *s2 = reinterpret_cast<S2*>(u);
std::cout << s2->i << std::endl;
}
}
int main() {
S1 s1{1};
printData(reinterpret_cast<U*>(&s1), 0);
S2 s2{2};
printData(reinterpret_cast<U*>(&s2), 1);
}
But, if you give a wrong type parameter to the printData-function, the behavior is undefined.
In c++ it is hard to imagine a program with a good design where the cast would be needed. In c if you already have a need for a union object there might be a case where this could be used to implement polymorphism (of course no reinterpret_cast there). Though it is usually done with void*.

Answer 2

The proper casting for such pointer casts is reinterpret_cast:
#include <stdio.h>
struct S1 {
int x,y;
};
struct S2 {
double a,b;
};
union U {
struct S1 as_s1;
struct S2 as_s2;
};
int main() {
struct S1 mys1;
union U *uptr = reinterpret_cast<union U*>(&mys1);
uptr->as_s1.x = 42;
printf("%d\n",mys1.x);
return 0;
}
Beware that since sizeof(struct S1) < sizeof(struct S2), in this example, and you only allocated enough memory for the size of S1, if you try to do anything on uptr->as_s1.b you will corrupt the stack.