C++ Unions

Unions in C++ are a special data structure that is defined using the union keyword, which stores different data types in the same memory location. Also, in a union, only one member can store a value at a time. In this article, we will discuss what a union is in C++, creating a union, assigning and accessing a union, the size of a union, nested unions, anonymous unions, local and global unions, unrestricted unions, union-like classes, and best practices for using a union in C++.

Table of Contents:

• What is a Union in C++?
• How to Declare and Create a Union in C++ with Syntax?
• When Should You Use a Union in C++?
• Accessing and Modifying Union Members in C++
• How to Find the Size of a Union in C++?
• How to Use Nested Unions in C++ (With Code Examples)?
• Anonymous Unions in C++: When and How to Use?
• Need for Unions in C++
• Scope of Unions in C++: Local vs Global
• Unrestricted Unions in C++ (C++11 and Later)
• Modern Alternatives to Unions in C++
• Difference between Union and Structure in C++
• Common Errors and Mistakes When Using Unions in C++
• Best Practices for Using Unions in C++

What is a Union in C++?

A union in C++ is a special data structure that allows for storing different data types in the same memory location. It allocates enough memory to store the largest member, which means that at any given time, it can store a value of only one of its members. The size of the union is determined by the largest member.

Syntax:

union UnionName {
    type member1;
    type member2;
    // other members...
};

Here,

• union: It is a keyword used to define a union.
• UnionName: It is the name of the union, which can be any valid identifier. 
• type: It can be any valid C++ data type, such as int, float, char, etc.
• member1, member2: These are the members of the union.

How to Declare and Create a Union in C++ with Syntax?

Creating a union is simple in C++. Below is a step-by-step procedure for defining, declaring, and using a union in C++:

1. Declaring a Union

At first, declare a union using the union keyword followed by the union name and its members using the given syntax.

Syntax:

union UnionName {
    type member1;
    type member2;
    // other members...
};

2. Creating a Union Variable

Now, a union variable can be created once a union is declared.

Syntax:

UnionName variableName;

A union variable can also be created during defining the union.

Example:

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

When Should You Use a Union in C++?

Unions are best used when:

• You need to store different types of data, but only one at a time.
• Memory optimization is crucial.
• You are working with hardware registers or data packets where the data format can change.

Here’s a simple C++ union example:

Output:

Note: Only the last value assigned (in this case data.f) remains valid.

Accessing and Modifying Union Members in C++

Accessing and assigning values to the union members in C++ is also simple and easy. The member that was recently assigned can only be read because of the shared memory feature of the unions. Also, accessing any other member than the recently assigned one will lead to undefined behavior.

1. Assigning a Union

A value can be assigned to a union member using the assignment operator in C++.

Example:

Output:

The code shows how union members are assigned and accessed in C++, since all the members share the same memory, thus, each new assignment overwrites the previous one, and then the result is printed to the console.

2. Accessing Union Members

The dot operator (.) in C++ can be used to access the union members. Also, the arrow operator (->) can be used to access a union member.

Example:

Output:

The code shows how the union members are accessed using the dot (.) operator, and only recently assigned member charVal stores a valid value due to the shared memory, which is then printed to the console.

How to Find the Size of a Union in C++ with Example?

Since all the members share the same memory location, thus, the size of a union is equal to the largest member of the union.

Example:

Output:

The code shows that the size of a union Data 4 bytes, which is equal to the size of its largest member, is determined and printed to the console.

How to Use Nested Unions in C++ (With Code Examples)?

A nested union in C++ is a union that can contain another union as a member. It is used when there is a need to organize the related data in the same memory location.

Syntax:

union OuterUnion {
    data_type1 outerMember1;
    data_type2 outerMember2;

    union InnerUnion {
        data_type3 innerMember1;
        data_type4 innerMember2;
    } innerUnionVar; // Optional variable name
};

A nested member can be accessed using the dot (.) operator in C++.

outer.inner.member

Example:

Output:

The code shows how a nested union is defined, and values are assigned to id, info.marks, info.grade, which overwrites the previous value, and then all the members with values are printed to the console as a result.

Anonymous Unions in C++: When and How to Use?

An anonymous union in C++ is a union without a name that is directly declared in a scope such as global, namespace, class, or struct. The members of the anonymous union as accessed directly without any variable or union name. Also, members of an anonymous union must not have any access specifiers if the members are declared outside of the class.

Example:

Output:

The code shows how an anonymous union is used inside a structure in which the union members, hourly wage, and salary, are accessed directly without any union name, and the salary is printed to the console after being assigned.

Need for Unions in C++ 

• Unions are needed in C++ because they save memory space by sharing space between all the members.
• In a union, only one member can store a valid value at a time.
• Unions are useful in embedded systems and also in performance-based applications.
• A union is ideal for type-punning and low-level data interpretation.
• They also help to store only one value at a time out of several possible types in a single variable.

Scope of Unions in C++: Local vs Global

A union can be declared at both global and local scopes based on its use cases.

1. Global Union

A global union is declared outside of all the functions in the program. It can be accessed through a file or a program. It is used across multiple functions. Also, it can maintain its value until the program runs.

Example:

Output:

The code shows how a global union, GlobalData, is declared outside the main function and also allows its variable g to be accessed and modified in the program.

2. Local Union

A local union is defined inside a function and is accessible only within the scope of that function. It is used when the union is needed temporarily and does not need to be visible globally.

Example:

Output:

The code shows how a local union, LocalData, is defined in the main function, in which the ch member is assigned a value, and then the values are accessed and printed to the console.

Unrestricted Unions in C++ (C++11 and Later)

The unrestricted unions in C++11 and the later versions can have non-trivial types such as std::string or classes with constructors and destructors. But they need manual construction and destruction of such members by using the placement new operator and by calling destructors explicitly.

Example:

Output:

The code shows how an unrestricted union, which has a std::string, and the constructor and destructor are manually defined to manage this non-trivial data type member, and then it is printed with the value to the console.

Union-like Classes in C++

Union-like classes in C++ are the classes that behave like unions, as they store different types in the same memory space, but with safety and control. The union-like classes can be implemented manually using the std::variant or manual memory management.

Why Use Union-like Classes?

• Because they provide type safety and control better than the raw unions.
• They allow non-trivial types and constructors to be used in the program.
• They also support tagged unions by tracking the active type in the program.

Example:

Output:

The code shows how a union-like class Wallet stores either an integer cash amount or a card name and simulates how a real wallet carries either, but not both, at once. It uses an enum for tracking the active member, and then prints the current value to the console.

Modern Alternatives to Unions in C++

With modern C++ (C++17 and above), you can use std::variant as a safer alternative to traditional unions.

Example:

Output:

Benefits over traditional unions:

• Type-safe (you can reliably determine and enforce the active data type at runtime).
• Supports types with constructors and destructors.
• No risk of undefined behavior from accessing the wrong member.
• While traditional unions still have their place in performance-critical applications, std::variant is a recommended choice for most modern C++ code.

Difference between Union and Structure in C++

Advantages and Limitations of Unions in C++

Advantages:

• Efficient Memory Usage: All members share the same memory space, making it efficient.
• Useful in Low-Level Programming: Ideal when interfacing with hardware or handling raw memory.
• Can be part of nested union C++ structures for advanced memory control.

Limitations:

• It doesn’t support features like constructors, destructors, or non-trivial data types in older C++ standards.
• You can only access one member at a time.
• Misuse can easily lead to undefined behavior.

Common Errors and Mistakes When Using Unions in C++

When working with unions, beginners often make these mistakes:

• Accessing an inactive member (i.e., using a member that was not last written to).
• Assuming unions hold multiple values at once (they don’t).
• Using types with non-trivial constructors without proper C++11+ support.
• Not distinguishing between the difference between union and struct in C++, leading to design flaws.

Also, be cautious when using anonymous union in C++, as they do not require a name and can create confusion in large codebases if not clearly documented.

Best Practices for Using Unions in C++

1. You should use unions when there is a need for memory optimization.
2. Always use an enum or a flag to keep track of the active member in the program.
3. You should avoid storing non-trivial types in the traditional unions.
4. You should not read from a member who was not the most recent writer.
5. You must use std::variant in modern C++ wherever it is possible.
6. Always avoid unions for complex logic and large applications.
7. You should initialize a union carefully to maintain a consistent state.
8. Always comment your code properly when unions are used because unions can confuse readers.

Conclusion

Unions are an important way to save memory space in programs. They are powerful data structures that provide type-safety and low-level data handling. But also, unions are used with much more care as they can cause errors or undefined behavior easily. So, by understanding what unions are, how to declare them, how to create a union, assigning and accessing the values, you can write an efficient C++ code using unions.

C++ Unions – FAQs