Examples of Union in C [closed]

Answer 1

struct InputEvent
{
    enum EventType
    {
        EventKeyPressed,
        EventKeyPressRepeated,
        EventKeyReleased,
        EventMousePressed,
        EventMouseMoved,
        EventMouseReleased
    } Type;
    union
    {
        unsigned int KeyCode;
        struct
        {
            int x;
            int y;
            unsigned int ButtonCode;
        };
    };
};
...
std::vector<InputEvent>   InputQueue;

with the union hack I can simply make a vector of objects. I'm sure this could be made more clean...but it works for me - KISS

Answer 2

Coincidentally, I just used one in a Stackoverflow answer here so I could treat a word that was made up of 6 bit fields as two 16 bit unsigned integers.

Years ago, I also used one for (the first) ARM C compiler - the instructions in those days were all 32 bit, but had different layouts depending on the exact instruction. So I had a union to represent an ARM instruction, containing a set of structs which each had the appropriate bitfields for a specific instruction type.

Answer 3

One classic is to represent a value of "unknown" type, as in the core of a simplistic virtual machine:

typedef enum { INTEGER, STRING, REAL, POINTER } Type;

typedef struct
{
  Type type;
  union {
  int integer;
  char *string;
  float real;
  void *pointer;
  } x;
} Value;

Using this you can write code that handles "values" without knowing their exact type, for instance implement a stack and so on.

Since this is in (old, pre-C11) C, the inner union must be given a field name in the outer struct. In C++ you can let the union be anonymous. Picking this name can be hard. I tend to go with something single-lettered, since it is almost never referenced in isolation and thus it is always clear from context what is going on.

Code to set a value to an integer might look like this:

Value value_new_integer(int v)
{
  Value v;
  v.type = INTEGER;
  v.x.integer = v;
  return v;
}

Here I use the fact that structs can be returned directly, and treated almost like values of a primitive type (you can assign structs).

Answer 4

#define DWORD unsigned int
#define WORD  unsigned short
#define BYTE  unsigned char

typedef union _DWORD_PART_ {

   DWORD dwWord;

   struct {
      WORD dwMSB;
      WORD dwLSB;
   }hw;

   struct {

      BYTE byMSB;
      BYTE byMSBL;
      BYTE byLSBH;
      BYTE byLSB;

   } b;

} DWORD_PART;

This is an easy way to access the words parts. (An once you are done, any change in endianness of the platform can also be handled easily)

Answer 5

We use unions for packed messages at work (C/C++), so we can pass around a structure with a union as a data member, then access the correct path based on id field in the structure.

Worked fine until somebody wrote the structure to a file, now we are limited to the largest data used in the file, because even though there's a file version, nobody ever changed it....

So while useful for in-memory work, avoid blindly writing them to disk or network.

Answer 6

Unions are also commonly used in the lexical analysis and parsing stage of language processors, like compilers and interpreters. Here is one I'm editing right now.

union {
    char c;
    int i;
    string *s;
    double d;
    Expression *e;
    ExpressionList *el;
    fpos_t fp;
}

The union is used to associate semantic values with the tokens of the lexical analyzer and the productions of the parser. This practice is quite common in grammar generators, like yacc, which provides explicit support for it. The union can hold any of its values, but only one of them at the time. For instance, at any one point from the input file you've either read a character constant (stored in c), or an integer (stored in i) or a floating point number (stored in d). The grammar generator provides considerable assistance for determining which of the values is stored at any one time depending on the rule being processed.