What is a Union?

A union is a user-defined data type where all members share the same memory location. This means that at any given time, only one of the union's members can contain a value. The size of the union is determined by the size of its largest member.

Key Points about Unions

• Shared Memory Space:
  • All members of a union share the same memory location. This means that the union can only store one value at a time, and assigning a value to one member will overwrite the values of other members.
• Size of Union:
  • The size of a union is determined by the size of its largest member. This ensures that the union can accommodate the largest possible value that it can store.
• Initialization:
  • A union can only be initialized with one member at a time. When you initialize a union, you specify which member is being set.

  • union Data {
        int intValue;
        float floatValue;
        char charValue;
    };
    
    Data data = { 5 }; // Initializes intValue

• Active Member:
  • It is important to keep track of which member is currently active (i.e., which member was most recently assigned a value) because accessing a different member can lead to undefined behavior.
• Anonymous Unions:
  • Unions can be declared without a name, making their members directly accessible without an additional identifier.

  • union {
        int intValue;
        float floatValue;
    };
    
    intValue = 5;
    

• Type Safety:
  • Unions do not provide type safety. It's the programmer's responsibility to ensure that the correct member is accessed. Using techniques like tagged unions can help mitigate this risk.
• Constructors and Destructors:
  • Unions can have constructors and destructors in C++. However, only one member can be active at a time, so you need to be careful when initializing and destroying union members.

  • union Data {
        int intValue;
        float floatValue;
        
        Data() { intValue = 0; } // Constructor
        ~Data() { /* Custom destructor if needed */ }
    };
    

Defining a Union

To define a union in C++, you use the union keyword, followed by the union name and the members within curly braces. Here's a simple example:

union Data {
    int intValue;
    float floatValue;
    char charValue;
};

In this example, Data is a union with three members: intValue, floatValue, and charValue. All three members share the same memory space.

Size of Union

The size of union is always the size of the its largest member. For instance, in our example the size of the union Data would be the size of its largest member which is both integer and float, both are of 4 bytes.

Example 1:

// Union Data Size
#include <iostream>

union Data {
    int intValue;
    float floatValue;
    char charValue;
};

using namespace std;
int main()
{
    cout << "Size of Union Data: " << sizeof(Data) << endl;
}

Output:

Size of Union Data: 4

Here, it has the size of 4 which is the size of largest member (int | float).

Example 2:

// Union Data Size
#include <iostream>

union Data {
    int intValue;
    short shortValue;
    char charValue;
};

using namespace std;
int main()
{
    cout << "Size of Union Data: " << sizeof(Data) << endl;
}

Output:

Size of Union Data: 4

Here, 4 is the size of the largest member of union which is int only.

Accessing Union Members

You can access union members using the dot operator, similar to how you access struct members. However, since all members share the same memory, you should only set and read the value of the member that was most recently assigned.

#include <iostream>

// Union
union Data {
    int intValue;
    float floatValue;
    char charValue;
};

int main() {
    union Data data;
    
    std::cout << "Size of the Union: " << sizeof(Data) << std::endl;

    data.intValue = 5;
    std::cout << "intValue: " << data.intValue << std::endl;

    data.floatValue = 3.14;
    std::cout << "floatValue: " << data.floatValue << std::endl;
    std::cout << "intValue (after setting floatValue): " << data.intValue << std::endl;

    data.charValue = 'A';
    std::cout << "charValue: " << data.charValue << std::endl;
    std::cout << "intValue (after setting charValue): " << data.intValue << std::endl;

    return 0;
}

Output

Size of the Union: 4
intValue: 5
floatValue: 3.14
intValue (after setting floatValue): 1078523331
charValue: A
intValue (after setting charValue): 1078523201

This example demonstrates how setting one member of the union affects the values of other members, illustrating the shared memory concept.

Visualization of Union

Little-Endian Representation:

In little-endian format, the least significant byte (LSB) is stored at the smallest memory address, and the most significant byte (MSB) is stored at the highest.

Let's take the same Data union example and represent it in little-endian format:

union Data {
    int intValue;
    float floatValue;
    char charValue;
};

1 When intvalue is set to 5:

data.intValue = 5;

Memory (little-endian):
Address:   0x00   0x01   0x02   0x03
         +---------------------------+
         |  05  |  00  |  00  |  00  |
         +---------------------------+

2 When floatValue is set to 3.14:

data.floatValue = 3.14;

Memory (little-endian):
Address:   0x00   0x01   0x02   0x03
         +---------------------------+
         |  C3  |  F5  |  48  |  40  |
         +---------------------------+

3 When charValue is set to A:

data.charValue = 'A';

Memory (little-endian):
Address:   0x00   0x01   0x02   0x03
         +---------------------------+
         |  41  |  00  |  00  |  00  |
         +---------------------------+

0x41 = 65 (ASCII value for A)

Big-Endian Representation:

In Big-Endian, the most significant byte is stored at the smallest memory address.

1 When intValue is set to 5:

data.intValue = 5;

Memory (big-endian):
Address:   0x00   0x01   0x02   0x03
         +---------------------------+
         |  00  |  00  |  00  |  05  |
         +---------------------------+

2 When floatValue is set to 3.14:

data.floatValue = 3.14;

Memory (big-endian):
Address:   0x00   0x01   0x02   0x03
         +---------------------------+
         |  40  |  48  |  F5  |  C3  |
         +---------------------------+

3 When charValue is set to ‘A’:

data.charValue = 'A';

Memory (big-endian):
Address:   0x00   0x01   0x02   0x03
         +---------------------------+
         |  00  |  00  |  00  |  41  |
         +---------------------------+

Use Cases for Unions

Unions are particularly useful in situations where memory is a constraint and you need to store different types of data but never at the same time. Some common use cases include:

1. Memory Efficiency: Unions can save memory in embedded systems where memory resources are limited.
2. Type Punning: Unions can be used to access the same memory location in different ways, which can be useful in low-level programming, such as interpreting the bytes of a floating-point number as an integer.
3. Variant Data Types: When dealing with a variable that can hold different data types at different times, such as in a variant type or a tagged union.

Tagged Unions

To mitigate some of the risks associated with unions, programmers often use a technique called "tagged unions" or "discriminated unions." This involves combining a union with an enumeration that keeps track of the currently active member:

#include <iostream>

enum class DataType { INT, FLOAT, CHAR };

union Data {
    int intValue;
    float floatValue;
    char charValue;
};

struct TaggedData {
    DataType type;
    Data data;
};

int main() {
    TaggedData taggedData;

    taggedData.type = DataType::INT;
    taggedData.data.intValue = 5;

    if (taggedData.type == DataType::INT) {
        std::cout << "intValue: " << taggedData.data.intValue << std::endl;
    }

    taggedData.type = DataType::FLOAT;
    taggedData.data.floatValue = 3.14;

    if (taggedData.type == DataType::FLOAT) {
        std::cout << "floatValue: " << taggedData.data.floatValue << std::endl;
    }

    return 0;
}

In this example, TaggedData combines a union with an enumeration to keep track of which type is currently stored in the union, providing a safer and more manageable way to use unions.

Output:

intValue: 5
floatValue: 3.14