1
                            
union MyUnion {
                        

                            
2
                            
    int intValue;
                        

                            
3
                            
    double doubleValue;
                        

                            
4
                            
    char charArray[10];
                        

                            
5
                            
};
                        
                                
                            

                                
                                    

                            
1
                            
内存起始地址
                        

                            
2
                            
↓
                        

                            
3
                            
+------------+
                        

                            
4
                            
|            |  <-  intValue (4 bytes)  起始于 Union (联合) 的起始地址
                        

                            
5
                            
+------------+
                        

                            
6
                            
|            |
                        

                            
7
                            
|            |  <-  doubleValue (8 bytes) 起始于 Union (联合) 的起始地址，与 intValue 重叠
                        

                            
8
                            
+------------+
                        

                            
9
                            
|            |
                        

                            
10
                            
|            |
                        

                            
11
                            
|            |
                        

                            
12
                            
|            |
                        

                            
13
                            
|            |
                        

                            
14
                            
|            |
                        

                            
15
                            
+------------+  <- charArray[10] (10 bytes) 起始于 Union (联合) 的起始地址，与 intValue 和 doubleValue 重叠
                        
                                
                            

                                
                                    

                            
1
                            
struct MyStruct {
                        

                            
2
                            
    int intValue;     // 4 bytes
                        

                            
3
                            
    double doubleValue; // 8 bytes
                        

                            
4
                            
};
                        

                            
5
                            

                        

                            
6
                            
MyStruct s;
                        

                            
7
                            
s.intValue = 10;
                        

                            
8
                            
s.doubleValue = 3.14;
                        

                            
9
                            

                        

                            
10
                            
// s 在内存中会分配 4 + 8 = 12 字节 (不考虑对齐，实际可能更大)
                        

                            
11
                            
// intValue 和 doubleValue 各自占用独立的内存空间
                        
                                
                            

                                
                                    

                            
1
                            
union MyUnion {
                        

                            
2
                            
    int intValue;     // 4 bytes
                        

                            
3
                            
    double doubleValue; // 8 bytes
                        

                            
4
                            
};
                        

                            
5
                            

                        

                            
6
                            
MyUnion u;
                        

                            
7
                            
u.intValue = 10;
                        

                            
8
                            
std::cout << "intValue: " << u.intValue << std::endl; // 输出 10
                        

                            
9
                            
std::cout << "doubleValue: " << u.doubleValue << std::endl; // 输出的结果将是基于 intValue 的内存解释，可能不是期望的值
                        

                            
10
                            

                        

                            
11
                            
u.doubleValue = 3.14;
                        

                            
12
                            
std::cout << "intValue: " << u.intValue << std::endl; // 输出的结果将是基于 doubleValue 的内存解释，可能不是期望的值
                        

                            
13
                            
std::cout << "doubleValue: " << u.doubleValue << std::endl; // 输出 3.14
                        

                            
14
                            

                        

                            
15
                            
// u 在内存中只会分配 8 字节 (取最大成员 doubleValue 的大小)
                        

                            
16
                            
// intValue 和 doubleValue 共享相同的 8 字节内存空间
                        
                                
                            

                                
                                    

                            
1
                            
union FloatInt {
                        

                            
2
                            
    float f;
                        

                            
3
                            
    int i;
                        

                            
4
                            
};
                        

                            
5
                            

                        

                            
6
                            
FloatInt fi;
                        

                            
7
                            
fi.f = 3.14f;
                        

                            
8
                            
std::cout << "Float value: " << fi.f << std::endl; // 输出 3.14
                        

                            
9
                            
std::cout << "Integer representation of float: " << fi.i << std::endl; // 输出 3.14 的整数表示
                        
                                
                            

                                
                                    

                            
1
                            
enum PacketType {
                        

                            
2
                            
    TYPE_A,
                        

                            
3
                            
    TYPE_B
                        

                            
4
                            
};
                        

                            
5
                            

                        

                            
6
                            
struct Packet {
                        

                            
7
                            
    PacketType type;
                        

                            
8
                            
    union {
                        

                            
9
                            
        struct { // Type A specific data
                        

                            
10
                            
            int id;
                        

                            
11
                            
            char name[32];
                        

                            
12
                            
        } typeAData;
                        

                            
13
                            
        struct { // Type B specific data
                        

                            
14
                            
            double value;
                        

                            
15
                            
        } typeBData;
                        

                            
16
                            
    } data;
                        

                            
17
                            
};
                        

                            
18
                            

                        

                            
19
                            
Packet pkt;
                        

                            
20
                            
pkt.type = TYPE_A;
                        

                            
21
                            
pkt.data.typeAData.id = 123;
                        

                            
22
                            
strcpy(pkt.data.typeAData.name, "Packet A");
                        

                            
23
                            

                        

                            
24
                            
pkt.type = TYPE_B;
                        

                            
25
                            
pkt.data.typeBData.value = 9.87;
                        
                                
                            

                                
                                    

                            
1
                            
enum DataType {
                        

                            
2
                            
    INT_TYPE,
                        

                            
3
                            
    DOUBLE_TYPE
                        

                            
4
                            
};
                        

                            
5
                            

                        

                            
6
                            
struct VariantData {
                        

                            
7
                            
    DataType typeFlag;
                        

                            
8
                            
    union {
                        

                            
9
                            
        int intValue;
                        

                            
10
                            
        double doubleValue;
                        

                            
11
                            
    };
                        

                            
12
                            
};
                        

                            
13
                            

                        

                            
14
                            
VariantData vd;
                        

                            
15
                            
vd.typeFlag = INT_TYPE;
                        

                            
16
                            
vd.intValue = 100;
                        

                            
17
                            

                        

                            
18
                            
if (vd.typeFlag == INT_TYPE) {
                        

                            
19
                            
    std::cout << "Integer value: " << vd.intValue << std::endl;
                        

                            
20
                            
} else if (vd.typeFlag == DOUBLE_TYPE) {
                        

                            
21
                            
    std::cout << "Double value: " << vd.doubleValue << std::endl;
                        

                            
22
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
union union-name {
                        

                            
2
                            
    member-type1 member-name1;
                        

                            
3
                            
    member-type2 member-name2;
                        

                            
4
                            
    // ...
                        

                            
5
                            
    member-typeN member-nameN;
                        

                            
6
                            
};
                        
                                
                            

                                
                                    

                            
1
                            
// 声明一个名为 DataUnion 的 Union (联合) 类型
                        

                            
2
                            
union DataUnion {
                        

                            
3
                            
    int i;          // 整型成员
                        

                            
4
                            
    float f;        // 浮点型成员
                        

                            
5
                            
    char str[20];   // 字符数组成员
                        

                            
6
                            
};
                        

                            
7
                            

                        

                            
8
                            
// 声明一个 Union (联合) 变量
                        

                            
9
                            
DataUnion myData;
                        
                                
                            

                                
                                    

                            
1
                            
struct MyStruct {
                        

                            
2
                            
    int type;
                        

                            
3
                            
    union { // 匿名 Union (联合)
                        

                            
4
                            
        int intValue;
                        

                            
5
                            
        float floatValue;
                        

                            
6
                            
    }; // 匿名 Union (联合) 没有名称
                        

                            
7
                            
};
                        

                            
8
                            

                        

                            
9
                            
MyStruct ms;
                        

                            
10
                            
ms.type = 1;
                        

                            
11
                            
ms.intValue = 100; // 直接访问匿名 Union (联合) 的成员 intValue
                        
                                
                            

                                
                                    

                            
1
                            
union MyUnion {
                        

                            
2
                            
    int intValue;
                        

                            
3
                            
    double doubleValue;
                        

                            
4
                            
};
                        

                            
5
                            

                        

                            
6
                            
MyUnion u1; // 默认初始化，intValue 和 doubleValue 的值都是不确定的
                        
                                
                            

                                
                                    

                            
1
                            
union MyUnion {
                        

                            
2
                            
    int intValue;
                        

                            
3
                            
    double doubleValue;
                        

                            
4
                            
};
                        

                            
5
                            

                        

                            
6
                            
MyUnion u2 = {10}; // 使用初始化列表初始化，intValue 被初始化为 10，doubleValue 的值是不确定的
                        

                            
7
                            
MyUnion u3 = {3.14}; // 错误！在 C++98/03 中，不能用 double 值初始化，因为第一个成员是 int
                        
                                
                            

                                
                                    

                            
1
                            
union MyUnion {
                        

                            
2
                            
    int intValue;
                        

                            
3
                            
    double doubleValue;
                        

                            
4
                            
};
                        

                            
5
                            

                        

                            
6
                            
MyUnion u4 = {.doubleValue = 3.14}; // C++11 指定成员初始化，doubleValue 被初始化为 3.14，intValue 的值是不确定的
                        

                            
7
                            
MyUnion u5 = {.intValue = 10};    // C++11 指定成员初始化，intValue 被初始化为 10，doubleValue 的值是不确定的
                        
                                
                            

                                
                                    

                            
1
                            
union Point {
                        

                            
2
                            
    int x;
                        

                            
3
                            
    int y;
                        

                            
4
                            
};
                        

                            
5
                            

                        

                            
6
                            
Point p1 = {1, 2}; // 错误！在 Union (联合) 中，聚合初始化只能初始化第一个成员
                        

                            
7
                            
Point p2 = {1};    // 正确，初始化第一个成员 x 为 1
                        

                            
8
                            

                        

                            
9
                            
union Data {
                        

                            
10
                            
    int i;
                        

                            
11
                            
    struct {
                        

                            
12
                            
        char c;
                        

                            
13
                            
        int j;
                        

                            
14
                            
    } nested;
                        

                            
15
                            
};
                        

                            
16
                            

                        

                            
17
                            
Data d1 = {.nested = {'A', 100}}; // C++20 允许对嵌套聚合类型进行指定初始化
                        
                                
                            

                                
                                    

                            
1
                            
union DataUnion {
                        

                            
2
                            
    int intValue;
                        

                            
3
                            
    double doubleValue;
                        

                            
4
                            
    char charArray[10];
                        

                            
5
                            
};
                        

                            
6
                            

                        

                            
7
                            
DataUnion myUnion;
                        

                            
8
                            

                        

                            
9
                            
myUnion.intValue = 10; // 为 intValue 成员赋值
                        

                            
10
                            
int val = myUnion.intValue; // 访问 intValue 成员的值
                        

                            
11
                            
std::cout << "intValue: " << val << std::endl; // 输出 10
                        

                            
12
                            

                        

                            
13
                            
myUnion.doubleValue = 3.14; // 为 doubleValue 成员赋值，此时 intValue 的值将不再有效
                        

                            
14
                            
double dVal = myUnion.doubleValue; // 访问 doubleValue 成员的值
                        

                            
15
                            
std::cout << "doubleValue: " << dVal << std::endl; // 输出 3.14
                        
                                
                            

                                
                                    

                            
1
                            
DataUnion* unionPtr = &myUnion;
                        

                            
2
                            
unionPtr->intValue = 20; // 通过指针为 intValue 成员赋值
                        

                            
3
                            
int ptrVal = unionPtr->intValue; // 通过指针访问 intValue 成员的值
                        

                            
4
                            
std::cout << "intValue via pointer: " << ptrVal << std::endl; // 输出 20
                        
                                
                            

                                
                                    

                            
1
                            
union ExampleUnion {
                        

                            
2
                            
    int i;
                        

                            
3
                            
    float f;
                        

                            
4
                            
};
                        

                            
5
                            

                        

                            
6
                            
ExampleUnion eu;
                        

                            
7
                            
eu.i = 10; // 先给 intValue 赋值
                        

                            
8
                            
std::cout << "intValue: " << eu.i << std::endl; // 输出 10
                        

                            
9
                            
std::cout << "floatValue (after intValue assignment): " << eu.f << std::endl; // 类型双关，将 intValue 的内存解释为 float
                        

                            
10
                            

                        

                            
11
                            
eu.f = 3.14f; // 后给 floatValue 赋值，覆盖了之前的 intValue
                        

                            
12
                            
std::cout << "intValue (after floatValue assignment): " << eu.i << std::endl; // 类型双关，将 floatValue 的内存解释为 int
                        

                            
13
                            
std::cout << "floatValue: " << eu.f << std::endl; // 输出 3.14
                        
                                
                            

                                
                                    

                            
1
                            
#include <iostream>
                        

                            
2
                            
#include <string>
                        

                            
3
                            

                        

                            
4
                            
enum ConfigType {
                        

                            
5
                            
    INT_CONFIG,
                        

                            
6
                            
    FLOAT_CONFIG,
                        

                            
7
                            
    STRING_CONFIG
                        

                            
8
                            
};
                        

                            
9
                            

                        

                            
10
                            
union ConfigValue {
                        

                            
11
                            
    int intVal;
                        

                            
12
                            
    float floatVal;
                        

                            
13
                            
    char stringVal[32]; // 假设字符串最大长度为 31
                        

                            
14
                            
};
                        

                            
15
                            

                        

                            
16
                            
struct ConfigItem {
                        

                            
17
                            
    ConfigType type;
                        

                            
18
                            
    ConfigValue value;
                        

                            
19
                            
};
                        

                            
20
                            

                        

                            
21
                            
int main() {
                        

                            
22
                            
    ConfigItem configItems[3];
                        

                            
23
                            

                        

                            
24
                            
    // 配置项 1: 整型
                        

                            
25
                            
    configItems[0].type = INT_CONFIG;
                        

                            
26
                            
    configItems[0].value.intVal = 100;
                        

                            
27
                            

                        

                            
28
                            
    // 配置项 2: 浮点型
                        

                            
29
                            
    configItems[1].type = FLOAT_CONFIG;
                        

                            
30
                            
    configItems[1].value.floatVal = 3.14f;
                        

                            
31
                            

                        

                            
32
                            
    // 配置项 3: 字符串型
                        

                            
33
                            
    configItems[2].type = STRING_CONFIG;
                        

                            
34
                            
    strcpy(configItems[2].value.stringVal, "hello");
                        

                            
35
                            

                        

                            
36
                            
    for (int i = 0; i < 3; ++i) {
                        

                            
37
                            
        std::cout << "Config Item " << i + 1 << ": ";
                        

                            
38
                            
        switch (configItems[i].type) {
                        

                            
39
                            
            case INT_CONFIG:
                        

                            
40
                            
                std::cout << "Type: Integer, Value: " << configItems[i].value.intVal << std::endl;
                        

                            
41
                            
                break;
                        

                            
42
                            
            case FLOAT_CONFIG:
                        

                            
43
                            
                std::cout << "Type: Float, Value: " << configItems[i].value.floatVal << std::endl;
                        

                            
44
                            
                break;
                        

                            
45
                            
            case STRING_CONFIG:
                        

                            
46
                            
                std::cout << "Type: String, Value: " << configItems[i].value.stringVal << std::endl;
                        

                            
47
                            
                break;
                        

                            
48
                            
            default:
                        

                            
49
                            
                std::cout << "Unknown Type" << std::endl;
                        

                            
50
                            
                break;
                        

                            
51
                            
        }
                        

                            
52
                            
    }
                        

                            
53
                            

                        

                            
54
                            
    std::cout << "Size of ConfigItem: " << sizeof(ConfigItem) << " bytes" << std::endl;
                        

                            
55
                            
    // Size of ConfigItem 的大小取决于 ConfigValue 中最大成员的大小 (char stringVal[32])，加上 ConfigType 的大小
                        

                            
56
                            
    // 而不是 int + float + char[32] 的总和。
                        

                            
57
                            

                        

                            
58
                            
    return 0;
                        

                            
59
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
#include <iostream>
                        

                            
2
                            
#include <cstdint> // for std::uint32_t, std::uint64_t
                        

                            
3
                            

                        

                            
4
                            
union TypeConvert {
                        

                            
5
                            
    float floatVal;
                        

                            
6
                            
    int intVal;
                        

                            
7
                            
    std::uint32_t uint32Val; // 无符号 32 位整型，与 float 和 int 大小相同
                        

                            
8
                            
};
                        

                            
9
                            

                        

                            
10
                            
union DoubleConvert {
                        

                            
11
                            
    double doubleVal;
                        

                            
12
                            
    std::uint64_t uint64Val; // 无符号 64 位整型，与 double 大小相同
                        

                            
13
                            
};
                        

                            
14
                            

                        

                            
15
                            
int main() {
                        

                            
16
                            
    TypeConvert tc;
                        

                            
17
                            
    tc.floatVal = 12.5f;
                        

                            
18
                            

                        

                            
19
                            
    std::cout << "Float value: " << tc.floatVal << std::endl;
                        

                            
20
                            
    std::cout << "Integer representation (via Union): " << tc.intVal << std::endl;
                        

                            
21
                            
    std::cout << "Unsigned Integer representation (via Union): " << tc.uint32Val << " (hex: 0x" << std::hex << tc.uint32Val << std::dec << ")" << std::endl;
                        

                            
22
                            
    // 输出 floatVal 的内存表示，被解释为 int 和 uint32_t 的值
                        

                            
23
                            

                        

                            
24
                            
    DoubleConvert dc;
                        

                            
25
                            
    dc.doubleVal = 123.456;
                        

                            
26
                            
    std::cout << "\nDouble value: " << dc.doubleVal << std::endl;
                        

                            
27
                            
    std::cout << "Unsigned Long Long Integer representation (via Union): 0x" << std::hex << dc.uint64Val << std::dec << std::endl;
                        

                            
28
                            
    // 输出 doubleVal 的内存表示，被解释为 uint64_t 的值
                        

                            
29
                            

                        

                            
30
                            
    return 0;
                        

                            
31
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
enum DataTypeTag {
                        

                            
2
                            
    TYPE_INT,
                        

                            
3
                            
    TYPE_FLOAT,
                        

                            
4
                            
    TYPE_STRING
                        

                            
5
                            
};
                        
                                
                            

                                
                                    

                            
1
                            
union DataPayload {
                        

                            
2
                            
    int intValue;
                        

                            
3
                            
    float floatValue;
                        

                            
4
                            
    char stringValue[32]; // 假设字符串最大长度为 31
                        

                            
5
                            
};
                        
                                
                            

                                
                                    

                            
1
                            
struct TaggedValue {
                        

                            
2
                            
    DataTypeTag tag;
                        

                            
3
                            
    DataPayload payload;
                        

                            
4
                            
};
                        
                                
                            

                                
                                    

                            
1
                            
#include <iostream>
                        

                            
2
                            
#include <string.h> // for strcpy
                        

                            
3
                            

                        

                            
4
                            
// 步骤 ①: 定义数据类型标签枚举 (enum)
                        

                            
5
                            
enum DataTypeTag {
                        

                            
6
                            
    TYPE_INT,
                        

                            
7
                            
    TYPE_FLOAT,
                        

                            
8
                            
    TYPE_STRING
                        

                            
9
                            
};
                        

                            
10
                            

                        

                            
11
                            
// 步骤 ②: 定义 Union (联合) 类型
                        

                            
12
                            
union DataPayload {
                        

                            
13
                            
    int intValue;
                        

                            
14
                            
    float floatValue;
                        

                            
15
                            
    char stringValue[32];
                        

                            
16
                            
};
                        

                            
17
                            

                        

                            
18
                            
// 步骤 ③: 定义包含标签和 Union (联合) 的 Struct (结构体)
                        

                            
19
                            
struct TaggedValue {
                        

                            
20
                            
    DataTypeTag tag;
                        

                            
21
                            
    DataPayload payload;
                        

                            
22
                            
};
                        

                            
23
                            

                        

                            
24
                            
int main() {
                        

                            
25
                            
    TaggedValue data;
                        

                            
26
                            

                        

                            
27
                            
    // 存储整型数据
                        

                            
28
                            
    data.tag = TYPE_INT;
                        

                            
29
                            
    data.payload.intValue = 123;
                        

                            
30
                            
    std::cout << "Type: Integer, Value: " << data.payload.intValue << std::endl;
                        

                            
31
                            

                        

                            
32
                            
    // 存储浮点型数据
                        

                            
33
                            
    data.tag = TYPE_FLOAT;
                        

                            
34
                            
    data.payload.floatValue = 3.14159f;
                        

                            
35
                            
    std::cout << "Type: Float, Value: " << data.payload.floatValue << std::endl;
                        

                            
36
                            

                        

                            
37
                            
    // 存储字符串数据
                        

                            
38
                            
    data.tag = TYPE_STRING;
                        

                            
39
                            
    strcpy(data.payload.stringValue, "Hello Union!");
                        

                            
40
                            
    std::cout << "Type: String, Value: " << data.payload.stringValue << std::endl;
                        

                            
41
                            

                        

                            
42
                            
    return 0;
                        

                            
43
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
union ExampleUnion {
                        

                            
2
                            
    int intValue;
                        

                            
3
                            
    float floatValue;
                        

                            
4
                            
    char charValue;
                        

                            
5
                            
};
                        
                                
                            

                                
                                    

                            
1
                            
内存地址:      [起始地址] -> [起始地址+1] -> [起始地址+2] -> [起始地址+3]
                        

                            
2
                            
------------------------------------------------------------------
                        

                            
3
                            
Union 内存区域: [     字节 0     ] -> [     字节 1     ] -> [     字节 2     ] -> [     字节 3     ]
                        

                            
4
                            
------------------------------------------------------------------
                        

                            
5
                            
成员覆盖:      <----- intValue ----->
                        

                            
6
                            
             <----- floatValue ----->
                        

                            
7
                            
             <--- charValue ---->
                        
                                
                            

                                
                                    

                            
1
                            
#include <iostream>
                        

                            
2
                            

                        

                            
3
                            
union ExampleUnion {
                        

                            
4
                            
    int intValue;
                        

                            
5
                            
    float floatValue;
                        

                            
6
                            
    char charValue;
                        

                            
7
                            
};
                        

                            
8
                            

                        

                            
9
                            
int main() {
                        

                            
10
                            
    ExampleUnion myUnion;
                        

                            
11
                            

                        

                            
12
                            
    myUnion.intValue = 10;
                        

                            
13
                            
    std::cout << "intValue: " << myUnion.intValue << std::endl; // 输出 10
                        

                            
14
                            
    std::cout << "floatValue: " << myUnion.floatValue << std::endl; // 输出 1.4013e-44 (取决于内存解释)
                        

                            
15
                            
    std::cout << "charValue: " << myUnion.charValue << std::endl;   // 输出 '\n' (ASCII 码 10)
                        

                            
16
                            
    std::cout << "--------------------" << std::endl;
                        

                            
17
                            

                        

                            
18
                            

                        

                            
19
                            
    myUnion.floatValue = 3.14f;
                        

                            
20
                            
    std::cout << "intValue: " << myUnion.intValue << std::endl;     // 输出 1078523331 (浮点数的内存表示被解释为整数)
                        

                            
21
                            
    std::cout << "floatValue: " << myUnion.floatValue << std::endl; // 输出 3.14
                        

                            
22
                            
    std::cout << "charValue: " << myUnion.charValue << std::endl;   // 输出 '@' (浮点数内存的第一个字节的 ASCII 码)
                        

                            
23
                            
    std::cout << "--------------------" << std::endl;
                        

                            
24
                            

                        

                            
25
                            
    myUnion.charValue = 'A';
                        

                            
26
                            
    std::cout << "intValue: " << myUnion.intValue << std::endl;     // 输出 65 (字符 'A' 的 ASCII 码)
                        

                            
27
                            
    std::cout << "floatValue: " << myUnion.floatValue << std::endl; // 输出 9.11372e-44 (取决于内存解释)
                        

                            
28
                            
    std::cout << "charValue: " << myUnion.charValue << std::endl;   // 输出 'A'
                        

                            
29
                            
    std::cout << "--------------------" << std::endl;
                        

                            
30
                            

                        

                            
31
                            

                        

                            
32
                            
    return 0;
                        

                            
33
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
#include <iostream>
                        

                            
2
                            

                        

                            
3
                            
union AddressUnion {
                        

                            
4
                            
    int intValue;
                        

                            
5
                            
    float floatValue;
                        

                            
6
                            
};
                        

                            
7
                            

                        

                            
8
                            
int main() {
                        

                            
9
                            
    AddressUnion myUnion;
                        

                            
10
                            

                        

                            
11
                            
    // 获取 Union 对象的起始地址
                        

                            
12
                            
    void* unionAddress = static_cast<void*>(&myUnion);
                        

                            
13
                            

                        

                            
14
                            
    // 获取 Union 成员的地址
                        

                            
15
                            
    void* intAddress = static_cast<void*>(&myUnion.intValue);
                        

                            
16
                            
    void* floatAddress = static_cast<void*>(&myUnion.floatValue);
                        

                            
17
                            

                        

                            
18
                            
    std::cout << "Union 起始地址: " << unionAddress << std::endl;
                        

                            
19
                            
    std::cout << "intValue 成员地址: " << intAddress << std::endl;
                        

                            
20
                            
    std::cout << "floatValue 成员地址: " << floatAddress << std::endl;
                        

                            
21
                            

                        

                            
22
                            
    // 比较地址
                        

                            
23
                            
    if (unionAddress == intAddress && unionAddress == floatAddress) {
                        

                            
24
                            
        std::cout << "结论: Union 对象和所有成员共享相同的起始地址 🎉" << std::endl;
                        

                            
25
                            
    } else {
                        

                            
26
                            
        std::cout << "结论: 地址不相同，与预期不符 😥" << std::endl; // 不应该执行到这里
                        

                            
27
                            
    }
                        

                            
28
                            

                        

                            
29
                            
    return 0;
                        

                            
30
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
struct ExampleStruct {
                        

                            
2
                            
    int intValue;
                        

                            
3
                            
    float floatValue;
                        

                            
4
                            
};
                        
                                
                            

                                
                                    

                            
1
                            
内存地址:      [起始地址] -> [起始地址+4]
                        

                            
2
                            
---------------------------------------
                        

                            
3
                            
Struct 内存区域: [  intValue  ] -> [ floatValue ]
                        

                            
4
                            
---------------------------------------
                        
                                
                            

                                
                                    

                            
1
                            
#include <iostream>
                        

                            
2
                            
#include <string>
                        

                            
3
                            
#include <new> // placement new
                        

                            
4
                            

                        

                            
5
                            
union StringUnion {
                        

                            
6
                            
    int intValue;
                        

                            
7
                            
    std::string stringValue; // std::string 具有非平凡的构造和析构函数
                        

                            
8
                            

                        

                            
9
                            
    StringUnion() {
                        

                            
10
                            
        // 默认构造函数，初始化为 int 类型
                        

                            
11
                            
        intValue = 0;
                        

                            
12
                            
        std::cout << "StringUnion 默认构造函数: 初始化为 int" << std::endl;
                        

                            
13
                            
    }
                        

                            
14
                            

                        

                            
15
                            
    ~StringUnion() {
                        

                            
16
                            
        // 析构函数，需要显式析构 string 成员 (如果它是活跃成员)
                        

                            
17
                            
        if (isStringActive) {
                        

                            
18
                            
            stringValue.~basic_string(); // 显式调用 std::string 的析构函数
                        

                            
19
                            
            std::cout << "StringUnion 析构函数: 显式析构 string" << std::endl;
                        

                            
20
                            
        } else {
                        

                            
21
                            
            std::cout << "StringUnion 析构函数: 无需析构 string (非活跃成员)" << std::endl;
                        

                            
22
                            
        }
                        

                            
23
                            
    }
                        

                            
24
                            

                        

                            
25
                            
private:
                        

                            
26
                            
    bool isStringActive = false; // 标记当前活跃成员是否为 string
                        

                            
27
                            

                        

                            
28
                            
public:
                        

                            
29
                            
    void activateString(const std::string& str) {
                        

                            
30
                            
        if (!isStringActive) {
                        

                            
31
                            
            // 如果 string 不是活跃成员，需要使用 placement new 显式构造
                        

                            
32
                            
            new (&stringValue) std::string(str); // placement new
                        

                            
33
                            
            isStringActive = true;
                        

                            
34
                            
            std::cout << "激活 string 成员，并使用 placement new 构造" << std::endl;
                        

                            
35
                            
        } else {
                        

                            
36
                            
            stringValue = str; // 如果 string 已活跃，直接赋值
                        

                            
37
                            
            std::cout << "string 成员已活跃，直接赋值" << std::endl;
                        

                            
38
                            
        }
                        

                            
39
                            
        isStringActive = true; // 确保标记为 string 活跃
                        

                            
40
                            
    }
                        

                            
41
                            

                        

                            
42
                            
    void activateInt(int val) {
                        

                            
43
                            
        if (isStringActive) {
                        

                            
44
                            
            // 如果 string 是活跃成员，需要显式析构
                        

                            
45
                            
            stringValue.~basic_string(); // 显式调用 std::string 的析构函数
                        

                            
46
                            
            isStringActive = false;
                        

                            
47
                            
            std::cout << "切换到 int 成员前，显式析构 string" << std::endl;
                        

                            
48
                            
        }
                        

                            
49
                            
        intValue = val;
                        

                            
50
                            
        std::cout << "激活 int 成员，直接赋值" << std::endl;
                        

                            
51
                            
        isStringActive = false; // 标记为 int 活跃
                        

                            
52
                            
    }
                        

                            
53
                            

                        

                            
54
                            
    std::string getStringValue() const {
                        

                            
55
                            
        if (isStringActive) {
                        

                            
56
                            
            return stringValue;
                        

                            
57
                            
        } else {
                        

                            
58
                            
            return "Error: string member is not active!";
                        

                            
59
                            
        }
                        

                            
60
                            
    }
                        

                            
61
                            

                        

                            
62
                            
    int getIntValue() const {
                        

                            
63
                            
        if (!isStringActive) {
                        

                            
64
                            
            return intValue;
                        

                            
65
                            
        } else {
                        

                            
66
                            
            return -1; // 或者抛出异常，表示 int 成员非活跃
                        

                            
67
                            
        }
                        

                            
68
                            
    }
                        

                            
69
                            
};
                        

                            
70
                            

                        

                            
71
                            
int main() {
                        

                            
72
                            
    StringUnion myUnion; // 使用默认构造函数 (初始化为 int)
                        

                            
73
                            
    std::cout << "--------------------" << std::endl;
                        

                            
74
                            

                        

                            
75
                            
    myUnion.activateString("Hello Union"); // 激活 string 成员并构造
                        

                            
76
                            
    std::cout << "String Value: " << myUnion.getStringValue() << std::endl;
                        

                            
77
                            
    std::cout << "--------------------" << std::endl;
                        

                            
78
                            

                        

                            
79
                            
    myUnion.activateInt(123); // 切换到 int 成员，先析构 string
                        

                            
80
                            
    std::cout << "Int Value: " << myUnion.getIntValue() << std::endl;
                        

                            
81
                            
    std::cout << "--------------------" << std::endl;
                        

                            
82
                            

                        

                            
83
                            
    return 0; // myUnion 对象生命周期结束，调用析构函数 (此时活跃成员是 int，无需析构 string)
                        

                            
84
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
struct Packet {
                        

                            
2
                            
    int packetType; // 包类型 (Packet Type)
                        

                            
3
                            
    union PacketBody {
                        

                            
4
                            
        struct {
                        

                            
5
                            
            int data1;
                        

                            
6
                            
            int data2;
                        

                            
7
                            
        } typeA; // 类型 A (Type A) 的数据
                        

                            
8
                            
        struct {
                        

                            
9
                            
            char data3[32];
                        

                            
10
                            
        } typeB; // 类型 B (Type B) 的数据
                        

                            
11
                            
        float data4; // 类型 C (Type C) 的数据
                        

                            
12
                            
    } body; // 包体 (Packet Body)
                        

                            
13
                            
};
                        

                            
14
                            

                        

                            
15
                            
int main() {
                        

                            
16
                            
    Packet packet;
                        

                            
17
                            
    packet.packetType = 1; // 设置包类型为 1 (Type 1)
                        

                            
18
                            

                        

                            
19
                            
    if (packet.packetType == 1) {
                        

                            
20
                            
        packet.body.typeA.data1 = 10;
                        

                            
21
                            
        packet.body.typeA.data2 = 20;
                        

                            
22
                            
        printf("Type A: data1 = %d, data2 = %d\n", packet.body.typeA.data1, packet.body.typeA.data2);
                        

                            
23
                            
    } else if (packet.packetType == 2) {
                        

                            
24
                            
        strcpy(packet.body.typeB.data3, "Hello");
                        

                            
25
                            
        printf("Type B: data3 = %s\n", packet.body.typeB.data3);
                        

                            
26
                            
    }
                        

                            
27
                            
    return 0;
                        

                            
28
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
struct FileInfo {
                        

                            
2
                            
    enum Unit { BYTE, KB, MB } sizeUnit; // 大小单位 (Size Unit)
                        

                            
3
                            
    union FileSize {
                        

                            
4
                            
        long long bytes; // 字节 (Bytes)
                        

                            
5
                            
        double kilobytes; // 千字节 (Kilobytes)
                        

                            
6
                            
        double megabytes; // 兆字节 (Megabytes)
                        

                            
7
                            
    } size; // 文件大小 (File Size)
                        

                            
8
                            
};
                        

                            
9
                            

                        

                            
10
                            
int main() {
                        

                            
11
                            
    FileInfo file;
                        

                            
12
                            
    file.sizeUnit = FileInfo::BYTE;
                        

                            
13
                            
    file.size.bytes = 1024000;
                        

                            
14
                            
    printf("File size in bytes: %lld\n", file.size.bytes);
                        

                            
15
                            

                        

                            
16
                            
    file.sizeUnit = FileInfo::KB;
                        

                            
17
                            
    file.size.kilobytes = 1000.0;
                        

                            
18
                            
    printf("File size in kilobytes: %.2f\n", file.size.kilobytes);
                        

                            
19
                            
    return 0;
                        

                            
20
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
struct StatusRegister {
                        

                            
2
                            
    union {
                        

                            
3
                            
        unsigned int rawValue; // 原始值 (Raw Value)
                        

                            
4
                            
        struct {
                        

                            
5
                            
            unsigned int bit0 AlBeRt63EiNsTeIn 标志 A (Flag A)
                        

                            
6
                            
            unsigned int bit1 AlBeRt63EiNsTeIn 标志 B (Flag B)
                        

                            
7
                            
            unsigned int bit2_7 : 6; // 位 2-7 (Bit 2-7): 保留位 (Reserved)
                        

                            
8
                            
            unsigned int bit8_31 : 24; // 位 8-31 (Bit 8-31): 其他信息 (Other Information)
                        

                            
9
                            
        } bits; // 位域 (Bit Fields)
                        

                            
10
                            
    };
                        

                            
11
                            
};
                        

                            
12
                            

                        

                            
13
                            
int main() {
                        

                            
14
                            
    StatusRegister status;
                        

                            
15
                            
    status.rawValue = 0x8003; // 设置寄存器值 (Set Register Value)
                        

                            
16
                            

                        

                            
17
                            
    printf("Raw Value: 0x%X\n", status.rawValue);
                        

                            
18
                            
    printf("Bit 0 (Flag A): %d\n", status.bits.bit0);
                        

                            
19
                            
    printf("Bit 1 (Flag B): %d\n", status.bits.bit1);
                        

                            
20
                            
    printf("Bit 2-7 (Reserved): %d\n", status.bits.bit2_7);
                        

                            
21
                            
    return 0;
                        

                            
22
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
struct DataFormatA {
                        

                            
2
                            
    int id;
                        

                            
3
                            
    float value;
                        

                            
4
                            
};
                        

                            
5
                            

                        

                            
6
                            
struct DataFormatB {
                        

                            
7
                            
    char name[32];
                        

                            
8
                            
    int count;
                        

                            
9
                            
};
                        

                            
10
                            

                        

                            
11
                            
union DataPacket {
                        

                            
12
                            
    DataFormatA formatA; // 数据格式 A (Data Format A)
                        

                            
13
                            
    DataFormatB formatB; // 数据格式 B (Data Format B)
                        

                            
14
                            
};
                        

                            
15
                            

                        

                            
16
                            
int main() {
                        

                            
17
                            
    DataPacket packet;
                        

                            
18
                            
    int formatType = 1; // 假设格式类型 (Assume Format Type)
                        

                            
19
                            

                        

                            
20
                            
    if (formatType == 1) {
                        

                            
21
                            
        packet.formatA.id = 100;
                        

                            
22
                            
        packet.formatA.value = 3.14f;
                        

                            
23
                            
        printf("Format A: ID = %d, Value = %.2f\n", packet.formatA.id, packet.formatA.value);
                        

                            
24
                            
    } else if (formatType == 2) {
                        

                            
25
                            
        strcpy(packet.formatB.name, "Data Packet B");
                        

                            
26
                            
        packet.formatB.count = 50;
                        

                            
27
                            
        printf("Format B: Name = %s, Count = %d\n", packet.formatB.name, packet.formatB.count);
                        

                            
28
                            
    }
                        

                            
29
                            
    return 0;
                        

                            
30
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
#include <stdio.h>
                        

                            
2
                            
#include <string.h>
                        

                            
3
                            

                        

                            
4
                            
// 定义状态枚举 (Define State Enumeration)
                        

                            
5
                            
enum FileState {
                        

                            
6
                            
    STATE_IDLE,
                        

                            
7
                            
    STATE_OPENING,
                        

                            
8
                            
    STATE_PROCESSING,
                        

                            
9
                            
    STATE_CLOSING,
                        

                            
10
                            
    STATE_ERROR
                        

                            
11
                            
};
                        

                            
12
                            

                        

                            
13
                            
// 定义状态机结构体 (Define State Machine Structure)
                        

                            
14
                            
struct FileStateMachine {
                        

                            
15
                            
    FileState currentState; // 当前状态 (Current State)
                        

                            
16
                            
    union StateData {
                        

                            
17
                            
        char filename[64]; // 文件名 (Filename) (用于 OPENING 状态)
                        

                            
18
                            
        int fileHandle;     // 文件句柄 (File Handle) (用于 PROCESSING 状态)
                        

                            
19
                            
        int errorCode;      // 错误代码 (Error Code) (用于 ERROR 状态)
                        

                            
20
                            
    } data; // 状态数据 (State Data)
                        

                            
21
                            
};
                        

                            
22
                            

                        

                            
23
                            
// 状态机操作函数 (State Machine Operation Functions)
                        

                            
24
                            
void enterOpeningState(FileStateMachine* sm, const char* filename) {
                        

                            
25
                            
    sm->currentState = STATE_OPENING;
                        

                            
26
                            
    strcpy(sm->data.filename, filename);
                        

                            
27
                            
    printf("Entering OPENING state, filename: %s\n", sm->data.filename);
                        

                            
28
                            
}
                        

                            
29
                            

                        

                            
30
                            
void enterProcessingState(FileStateMachine* sm, int handle) {
                        

                            
31
                            
    sm->currentState = STATE_PROCESSING;
                        

                            
32
                            
    sm->data.fileHandle = handle;
                        

                            
33
                            
    printf("Entering PROCESSING state, file handle: %d\n", sm->data.fileHandle);
                        

                            
34
                            
}
                        

                            
35
                            

                        

                            
36
                            
void enterErrorState(FileStateMachine* sm, int error) {
                        

                            
37
                            
    sm->currentState = STATE_ERROR;
                        

                            
38
                            
    sm->data.errorCode = error;
                        

                            
39
                            
    printf("Entering ERROR state, error code: %d\n", sm->data.errorCode);
                        

                            
40
                            
}
                        

                            
41
                            

                        

                            
42
                            
void displayCurrentState(const FileStateMachine* sm) {
                        

                            
43
                            
    printf("Current State: ");
                        

                            
44
                            
    switch (sm->currentState) {
                        

                            
45
                            
        case STATE_IDLE:       printf("IDLE\n"); break;
                        

                            
46
                            
        case STATE_OPENING:    printf("OPENING\n"); break;
                        

                            
47
                            
        case STATE_PROCESSING: printf("PROCESSING\n"); break;
                        

                            
48
                            
        case STATE_CLOSING:    printf("CLOSING\n"); break;
                        

                            
49
                            
        case STATE_ERROR:      printf("ERROR\n"); break;
                        

                            
50
                            
        default:               printf("UNKNOWN\n"); break;
                        

                            
51
                            
    }
                        

                            
52
                            
}
                        

                            
53
                            

                        

                            
54
                            
int main() {
                        

                            
55
                            
    FileStateMachine fileSM;
                        

                            
56
                            
    fileSM.currentState = STATE_IDLE; // 初始状态 (Initial State)
                        

                            
57
                            

                        

                            
58
                            
    displayCurrentState(&fileSM); // 输出当前状态 (Output Current State)
                        

                            
59
                            

                        

                            
60
                            
    enterOpeningState(&fileSM, "my_file.txt"); // 进入 OPENING 状态 (Enter OPENING State)
                        

                            
61
                            
    displayCurrentState(&fileSM);
                        

                            
62
                            

                        

                            
63
                            
    enterProcessingState(&fileSM, 123); // 进入 PROCESSING 状态 (Enter PROCESSING State)
                        

                            
64
                            
    displayCurrentState(&fileSM);
                        

                            
65
                            

                        

                            
66
                            
    enterErrorState(&fileSM, -1); // 进入 ERROR 状态 (Enter ERROR State)
                        

                            
67
                            
    displayCurrentState(&fileSM);
                        

                            
68
                            

                        

                            
69
                            
    return 0;
                        

                            
70
                            
}