从语言的角度来看，行为是未定义的。考虑到不同的平台在内存对齐和字节序方面可能有不同的约束。大端序机器中的代码与小端序机器中的代码将以不同的方式更新结构中的值。修复语言中的行为将要求所有实现使用相同的字节序(和内存对齐约束……)来限制使用。

如果你正在使用c++(你正在使用两个标签)，你真的关心可移植性，那么你可以只使用结构和提供一个setter，采用uint32_t和设置字段适当通过位掩码操作。在C语言中用函数也可以做到这一点。

Edit: I was expecting AProgrammer to write down an answer to vote and close this one. As some comments have pointed out, endianness is dealt in other parts of the standard by letting each implementation decide what to do, and alignment and padding can also be handled differently. Now, the strict aliasing rules that AProgrammer implicitly refers to are a important point here. The compiler is allowed to make assumptions on the modification (or lack of modification) of variables. In the case of the union, the compiler could reorder instructions and move the read of each color component over the write to the colour variable.

正如其他人提到的，联合与枚举结合并包装成结构体可用于实现带标签的联合。一个实际用途是实现Rust的Result<T, E>，它最初是使用纯枚举实现的(Rust可以在枚举变量中保存额外的数据)。下面是一个c++的例子:

template <typename T, typename E> struct Result {
    public:
    enum class Success : uint8_t { Ok, Err };
    Result(T val) {
        m_success = Success::Ok;
        m_value.ok = val;
    }
    Result(E val) {
        m_success = Success::Err;
        m_value.err = val;
    }
    inline bool operator==(const Result& other) {
        return other.m_success == this->m_success;
    }
    inline bool operator!=(const Result& other) {
        return other.m_success != this->m_success;
    }
    inline T expect(const char* errorMsg) {
        if (m_success == Success::Err) throw errorMsg;
        else return m_value.ok;
    }
    inline bool is_ok() {
        return m_success == Success::Ok;
    }
    inline bool is_err() {
        return m_success == Success::Err;
    }
    inline const T* ok() {
        if (is_ok()) return m_value.ok;
        else return nullptr;
    }
    inline const T* err() {
        if (is_err()) return m_value.err;
        else return nullptr;
    }

    // Other methods from https://doc.rust-lang.org/std/result/enum.Result.html

    private:
    Success m_success;
    union _val_t { T ok; E err; } m_value;
}

在1974年记录的C语言中，所有结构成员共享一个公共名称空间，“ptr->成员”的含义被定义为添加 成员的位移到“ptr”，并使用 成员的类型。这种设计使得成员可以使用相同的ptr 名称取自不同的结构定义，但偏移量相同; 程序员将这种能力用于各种目的。

When structure members were assigned their own namespaces, it became impossible to declare two structure members with the same displacement. Adding unions to the language made it possible to achieve the same semantics that had been available in earlier versions of the language (though the inability to have names exported to an enclosing context may have still necessitated using a find/replace to replace foo->member into foo->type1.member). What was important was not so much that the people who added unions have any particular target usage in mind, but rather that they provide a means by which programmers who had relied upon the earlier semantics, for whatever purpose, should still be able to achieve the same semantics even if they had to use a different syntax to do it.

正如你所说，这是严格未定义的行为，尽管它将“工作”在许多平台上。使用联合的真正原因是为了创建不同的记录。

union A {
   int i;
   double d;
};

A a[10];    // records in "a" can be either ints or doubles 
a[0].i = 42;
a[1].d = 1.23;

当然，您还需要某种鉴别器来说明这个变体实际上包含了什么。注意，在c++中，联合的用处不大，因为它们只能包含POD类型——实际上是那些没有构造函数和析构函数的类型。

在c++中，Boost Variant实现了一个安全的联合版本，旨在尽可能地防止未定义的行为。

它的性能与enum + union结构相同(也分配了堆栈等)，但它使用类型的模板列表而不是enum:)

再举一个联合实际使用的例子，CORBA框架使用带标签的联合方法序列化对象。所有用户定义的类都是一个(巨大的)联合的成员，整数标识符告诉解编码器如何解释该联合。