how to pass the union pointer as parameter in C? and what is the inside of union?

Question

I have a question about union in c. The following code is the server side, we receive Signal2 from the client side, in the service function, can I check the signal type like this: data_p->header.type? and in the switch case, how could I pass the parameter to function printInfo(), the parameter of it is the pointer to the union, how to pass? And the last question is the pointer to the union, point to what? and what is inside of the union, when these three structs are allocated, how could they fit into the union(with the size of the large struct)?

   union
    {
        Header  header;
        Signal1 signal1;
        Signal2 signal2;
    } Data;

struct Header 
{   
    int type:
    int protocol;
    int clientId;
    int serverId;
};


struct Signal1
{
    int type:
    int protocol;
    int clientId;
    int serverId;
    char[80] something;
};


struct Signal2
{
    int type:
    int protocol;
    int clientId;
    int serverId;
    int[100] something;
};


void service(Data* data_p) {

    switch(data_p->header.type) {
        case 1:
            printInfo(&data_p->header);
        case 2:
            printInfo(data_p->header);
        case 3:
            data_p->signal2->something[5];
    }   
}


void printInfo(Data* data_p) 
{
    data_p->header.primitive;
}

@Richard: I believe that the layout of the struct may vary between compilers. but compilers are supposed to create the same alignment for these different structures and its safe to rely on this fact. using the first byte as a type identifier is quite common. you can also force most compilers to pack the structure removing paddings. — Alexander Oh, Oct 05 '11 at 21:44
don't forget to break; after the switch's case parts are done. — wildplasser, Oct 05 '11 at 21:45

score 2 · Accepted Answer · answered Oct 05 '11 at 21:13

In your example it looks like you want to rely on the fact that the type, protocol, clientId, serverId fields from Header, Signal1, Signal2 will be aligned the same way. But nothing in the C or C++ standard guarantees that AFAIK. So it would probably work with most C compilers but it is a hack, where such a hack is not necessary.

It seems like it would be better to do things as follows :

struct Header 
{
    int type:
    int protocol;
    int clientId;
    int serverId;
};

struct Signal1
{
    char something[80];
};

struct Signal2
{
    char something[100];
};

struct Message
{
    struct Header header;
    union
    {
        struct Signal1 signal1;
        struct Signal2 signal2;
    } payload;
};

As for your last question if I understand it correctly, the union is allocated enough memory for the largest of it's members, and aligned at the strictest of it's members' boundaries, and at any point in time contains valid data for one of it's members (but nothing indicating which is the correct one). And the pointer to union is the address of the start of that memory area.

score 0 · Answer 2 · answered Oct 05 '11 at 21:10

0

I think your declaration of the union is the part that isn't working as expected.

Try the following.

union Data
{
    Header  header;
    Signal1 signal1;
    Signal2 signal2;
};

This should make a union type called Data instead of a single variable of an anonymous union type.

From here you should be able access the Header even when passed a Signal2 object via data_p->header.Type.

answered Oct 05 '11 at 21:10

Jason

3,736
5
33
40

if the object received is Signal2, how to access Header object through data_p->header.Type? – Oct 05 '11 at 21:22
You will need to cast the `Signal2` to a `Data` object. This will succeed because of how you have defined the union. `Signal2* signal2 = ;/*get from someplace*/ int type = ((Data*)signal2)->header.Type;` – Jason Oct 05 '11 at 21:55
I do not understand, when we send the signal2 from client, the signal2 is sent like this way: send(Data*(Signal2)); and the service(Data* data_p) receives this signal2, in this case, do I still need to cast it? – Oct 06 '11 at 07:01
If your service is returning a Data* then you don't need to cast. – Jason Oct 06 '11 at 17:25

score 0 · Answer 3 · answered Oct 05 '11 at 21:17

Something like

enum{Header,Signal1,Signal2} type = Header;

....
union Data
{
    Header header;
    Signal1 signal1;
    Signal2 signal2;
};

struct Packet
{
    type data_type; // points to one of Header, Signal1 or Signal2
    union Data data;
};

could be a good way of passing the pointer to what the union holds.

Or another argument to the function that processes the union, or a global variable, or a configuration parameter. As far as I know, what a union holds has to be explicitly told.

score 0 · Answer 4 · answered Oct 05 '11 at 21:22

I think the header structure in the union is meant to be the common prefix of variables. so you would check the type of this union like this:

 switch(data_p->header.type) {
     case 1:
         printInfo(data_p);
     case 2: //unknown type?
         printInfo(data_p);
     case 3: // type is obviously signal2
         data_p->signal2->something[5];
 }

So yes you can check with data_p->header.type. it seems to me that you could rewrite the code a little to get it more obvious

enum { 
  HEADER_TYPE  = 1, // fill in the correct type numbers here to match the documentation
  SIGNAL1_TYPE = 2,
  SIGNAL2_TYPE = 3
};
switch(data_p->header.type) {
    case 1:
        printInfo(data_p);
    case 2: //unknown type?
        printInfo(data_p);
    case SIGNAL2_TYPE: // type is obviously signal2
        data_p->signal2->something[5];
}

the other thing i notices in printInfo header doesn't have a variable called primitive from the switch statement you would call use printInfo(data_p) to call it correctly.

The most important thing here is that the programmer has to make sure that the type variable is always set to the correct value, corresponding to the right struct of the union part. i.e. if the struct is a signal1 its 1 and if it is a signal2 its 2 and so on

But the use of the union is quite useless here, since all fields are identical except the last one and the header is obviously meant to access the common fields.

struct Header
{
  int type:
  int protocol;
  int clientId;
  int serverId;
};

struct Signal1
{
  struct Header header;
  int[80] something;
};

struct Signal2
{
  struct Header header;
  int[100] something;
};

enum { 
  SIGNAL1_TYPE = 0,
  SIGNAL2_TYPE
};

void service(struct Header* data_p) {

  switch(data_p->header.type) {
    default:
        printInfo(data_p);
      break;
    case SIGNAL1_TYPE:
        /* your code here */
        call_func( (struct Signal1 *) data_p );
      break;
    case SIGNAL2_TYPE:
        /* your code here */
        call_func( (struct Signal2 *) data_p );
      break;
  }

}

why we can check it like this way data_p->header.type? even we did not receive any Header object? — , Oct 05 '11 at 21:26
the keyword union means that it is one of those structures that are in the list. if you look closely you will notice that the structure header has the common members of both structures. Thus it is safe to assume, that we can access the common fields by using struct Header. — Alexander Oh, Oct 05 '11 at 21:28
but they are three different struct, and we got Signal2 object, not Header object. — , Oct 05 '11 at 21:30
the alignment of each struct is the same until your char something[80] thing. thus the memory layout of each struct is supposed to be identical here. you could also call data_p->signal2.type if you wanted to.. The implementation relies on the fact that the first field of all structures is type and the memory layout of all structures is identical in the first 16 bytes. — Alexander Oh, Oct 05 '11 at 21:40

score 0 · Answer 5 · answered Oct 05 '11 at 21:41

The syntax of accessing union members is very similar to that used to access structure members. One uses the . operator to access a union field through a plain union and the -> to access a union field through a pointer to union. Assuming the Data union in your example:

Data v;
Data *p = &v;
int ftype;

ftype = v.header.type;
ftype = p->header.type;

As to the parameter to printinfo, the parameter type shown in your code is correct, it should be a pointer to Data. However, the code inside printInfo is not correct, as pointed out elsewhere. I would expect it to contain a switch on the header type field similar to the one in the service method, as in the following:

void printInfo(Data* data_p) 
{
    printf("Type %d, protocol %d, clientId %d, serverId %d ",
         data_p->header.type, data_p.header.protocol,
         data_p->header.clientId, data_p->header.serverId);

    switch(data_p->header.type) {
        case 1:
            // Signal 1
            printf("signal 1 (string): %s", data_p->signal1.something);
        case 2:
            // Signal 2
            printf("signal 2 (int array): %d", data_p->signal2.something[0]);
        // and so on
    }
    printf("\n");
}

As has also been said elsewhere, a union only contains one of its members at a time. The compiler gives it enough space to contain the largest possible member. Storing one of the possible data types in a union overlays the data on whatever was there before.

The programmer must keep track of which of the possible elements has been put into a union, and access it appropriately. In the Data union in your example, the header.type field is used for this purpose.

score 0 · Answer 6 · edited May 23 '17 at 11:55

you need to specialize printinfo()

like void printinfo(Header*)

void printinfo(Signal1*)

void printinfo(Signal2*)

then pass it like case 2: printInfo(&data_p->signal1); // pass the right union member to the right function

so really you are not passing the union, you are passing the data inside the union.

second question: Unions are not structs. unions have the size of the largest member. you shoudl read sizeof a union in C/C++

good luck

how to pass the union pointer as parameter in C? and what is the inside of union?

6 Answers6