C++ Academy · Lesson

Unions and Their Risks

Share memory between types.

Lesson 2 of 413 steps

Unions and Their Risks is a free C++ Academy lesson on CoddyKit. This is lesson 2 of 4. Any 3 lessons of this learning path are free to read in full — after that, CoddyKit PRO unlocks every lesson, plus hands-on practice with a built-in code editor and a 24/7 AI tutor. It is part of the C++ Academy learning path, and your progress syncs across the web and the CoddyKit app. The C++ Academy course includes 4 lessons in total.

What Is a Union?

A union lets several members share the same memory. Only one member is valid at a time, and the union is only as big as its largest member.

#include <iostream>
union Number {
    int i;
    float f;
};
int main() {
    Number n;
    n.i = 42;
    std::cout << n.i << "\n";
}

Size of a Union

Because members overlap, sizeof a union equals the size of its largest member (plus any alignment padding), not the sum.

#include <iostream>
union Mix { char c; int i; double d; };
int main() {
    std::cout << sizeof(Mix) << "\n"; // size of double (often 8)
}

Writing One, Reading Another

Writing one member and reading a different one is the central risk. The bits are reinterpreted, which is usually undefined or surprising.

#include <iostream>
union Bits { int i; float f; };
int main() {
    Bits b;
    b.f = 1.0f;
    std::cout << b.i << "\n"; // reads float bits as int
}

Only One Active Member

The member you last wrote is the only one you may safely read. Track which member is "active" yourself; the union does not remember.

#include <iostream>
union Value { int i; double d; };
int main() {
    Value v;
    v.d = 3.14;        // d is active
    std::cout << v.d << "\n";
}

The Tagged Union Pattern

To use unions safely, pair them with a tag (an enum) that records the active member. This is the manual ancestor of std::variant.

#include <iostream>
struct Tagged {
    enum { Int, Double } tag;
    union { int i; double d; };
};
int main() {
    Tagged t; t.tag = Tagged::Int; t.i = 7;
    if (t.tag == Tagged::Int) std::cout << t.i << "\n";
}

Reading the Right Member

Always branch on the tag before reading. Reading the wrong member produces garbage values.

#include <iostream>
struct Tagged {
    enum { Int, Double } tag;
    union { int i; double d; };
};
void print(const Tagged& t) {
    if (t.tag == Tagged::Int) std::cout << "int " << t.i << "\n";
    else std::cout << "double " << t.d << "\n";
}
int main() { Tagged t{Tagged::Double}; t.d = 2.5; print(t); }

Non-Trivial Members

Putting a member with a constructor or destructor (like std::string) in a union requires manual construction and destruction. This is error-prone, another reason to prefer std::variant.

Anonymous Unions

An anonymous union has no name; its members are accessed directly. It is handy inside a struct, but the same active-member rule applies.

#include <iostream>
struct Packet {
    int kind;
    union { int code; char letter; };
};
int main() {
    Packet p; p.kind = 1; p.code = 99;
    std::cout << p.code << "\n";
}

Why Unions Are Risky

Summary of dangers:

No memory of which member is active.
Reading an inactive member is undefined behavior.
Non-trivial types need manual lifetime management.

When Unions Still Help

Unions remain useful for low-level work: reinterpreting bytes, saving memory in tight embedded code, or matching a fixed binary layout. For everyday "one of several types" data, prefer the safer alternative.

Toward std::variant

std::variant is a type-safe union that tracks the active type for you and throws if you access the wrong one. The rest of this course explores it.

Quick Check

Check your understanding of unions.

Answer it in the interactive lesson

Recap

You learned about unions:

All members share one block of memory.
Only the last-written member is valid to read.
Use a tag (enum) to track the active member.
Prefer std::variant for safety in modern C++.

Free to start

Learn C++ with an AI tutor — free

Write and run real code in your browser, get instant help from a 24/7 AI tutor, and pick up where you left off on the web or in the app.

Courses: 51
Lessons: 203

Start learning free View the full course

Frequently Asked Questions

Is the “Unions and Their Risks” lesson free?

Yes — any 3 lessons of the C++ Academy learning path, including “Unions and Their Risks”, are free to read in full here on the web. After that, CoddyKit PRO unlocks every lesson, plus interactive practice with a built-in code editor and a 24/7 AI tutor. The C++ Academy course includes 4 lessons in total.

What will I learn in “Unions and Their Risks”?

Share memory between types. You practise C++ Academy with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start C++ Academy?

No prior experience is required. C++ Academy on CoddyKit is structured for beginners through advanced learners, so you can start here or from the beginning and move at your own pace. This is lesson 2 of 4.

How long does the “Unions and Their Risks” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this C++ Academy lesson?

Yes. Every C++ Academy lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

← Back to C++ Academy