在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:

1. they are the same object, or
2. one is a standard-layout union object and the other is a non-static data member of that object (12.3),
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
4. 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. Eg, 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.