C++联合体与结构体组合使用方法

#include <iostream>
#include <string> // 尽管示例中未使用std::string作为联合体成员，但它是常见用例

// 定义一个枚举来标识联合体中存储的数据类型
enum class PointType {
    TwoD,
    ThreeD,
    Invalid // 一个默认或错误状态
};

// 定义2D点和3D点的结构
struct Point2D {
    double x;
    double y;
};

struct Point3D {
    double x;
    double y;
    double z;
};

// 组合结构体与联合体
struct VariantPoint {
    PointType type; // 标签，指示联合体中当前存储的是哪种类型
    union {
        Point2D p2d;
        Point3D p3d;
    }; // 匿名联合体，也可以是具名联合体，这里采用匿名更简洁
};

// 示例函数来处理这个变体点
void printPoint(const VariantPoint& vp) {
    switch (vp.type) {
        case PointType::TwoD:
            std::cout << "2D Point: (" << vp.p2d.x << ", " << vp.p2d.y << ")" << std::endl;
            break;
        case PointType::ThreeD:
            std::cout << "3D Point: (" << vp.p3d.x << ", " << vp.p3d.y << ", " << vp.p3d.z << ")" << std::endl;
            break;
        case PointType::Invalid:
        default:
            std::cout << "Invalid Point Type." << std::endl;
            break;
    }
}

int main() {
    VariantPoint vp1;
    vp1.type = PointType::TwoD;
    vp1.p2d = {10.0, 20.0}; // 设置2D点数据
    printPoint(vp1);

    VariantPoint vp2;
    vp2.type = PointType::ThreeD;
    vp2.p3d = {1.0, 2.0, 3.0}; // 设置3D点数据
    printPoint(vp2);

    // 尝试错误访问，这会导致未定义行为。
    // 编译器不会报错，但程序行为不可预测。
    // vp1.type = PointType::TwoD; // 明确设置为2D
    // std::cout << "Accessed 3D Z from 2D point (DANGEROUS!): " << vp1.p3d.z << std::endl; 

    return 0;
}

VariantPoint

PointType

union

Point2D

Point3D

type

TwoD

p2d

ThreeD

p3d

int i; float f;

sizeof(int) + sizeof(float)

union { int i; float f; };

max(sizeof(int), sizeof(float))

#include <cstring> // For strlen, strcpy

// 假设我们有一个简单的Token类型
enum class TokenType {
    Integer,
    String,
    Operator,
    None // 默认或未初始化状态
};

struct Token {
    TokenType type;
    union {
        int intValue;
        char* stringValue; // 注意：这里为了简化，使用char*，实际项目中应使用std::string或智能指针
        char opValue;
    };

    // 构造函数：初始化标签，并确保联合体处于已知状态
    Token() : type(TokenType::None) {
        // 对于非平凡类型，这里需要显式构造。对于char*，直接置空即可。
        // 如果是std::string，这里无需特殊处理，因为默认构造函数会被调用。
    }

    // 析构函数：如果联合体成员是非平凡类型且需要手动管理内存，这里必须处理
    ~Token() {
        if (type == TokenType::String && stringValue != nullptr) {
            delete[] stringValue; // 释放动态分配的字符串内存
        }
    }

    // 禁用拷贝构造和赋值运算符，除非你打算实现复杂的深拷贝逻辑
    // Token(const Token&) = delete;
    // Token& operator=(const Token&) = delete;

    // 辅助函数：设置字符串令牌
    void setString(const char* str) {
        if (type == TokenType::String && stringValue != nullptr) {
            delete[] stringValue; // 先释放旧的字符串内存
        }
        type = TokenType::String;
        if (str) {
            stringValue = new char[std::strlen(str) + 1];
            std::strcpy(stringValue, str);
        } else {
            stringValue = nullptr;
        }
    }

    // 辅助函数：设置整数令牌
    void setInt(int val) {
        if (type == TokenType::String && stringValue != nullptr) {
            delete[] stringValue; // 切换类型时，释放旧的字符串内存
        }
        type = TokenType::Integer;
        intValue = val;
    }

    // 辅助函数：设置操作符令牌
    void setOperator(char op) {
        if (type == TokenType::String && stringValue != nullptr) {
            delete[] stringValue; // 切换类型时，释放旧的字符串内存
        }
        type = TokenType::Operator;
        opValue = op;
    }
};

// 实际使用示例：
// int main() {
//     Token t;
//     t.setString("hello world");
//     std::cout << "