这确实是用C++实现递归联合时的典型坑——编译器处理union定义时，递归引用的Obj类型还没完成定义，直接把它作为union成员就会触发"不完整类型"的错误。下面给你两种简洁且实用的解决方案：

1. 使用原始指针（基础方案） #

指针的大小在编译期是固定的，不管指向的类型是否完整，编译器都能正常处理。我们可以把union里的Obj对象替换成Obj*指针：

#include <iostream>

// 前向声明Obj类型
struct Obj;

union RecursiveUnion {
    int int_value;
    Obj* obj_ptr; // 用指针代替直接存储对象
};

// 现在可以完整定义Obj了
struct Obj {
    RecursiveUnion u;
};

// 示例用法
int main() {
    Obj root;
    // 存储int类型
    root.u.int_value = 42;
    std::cout << "存储的整数：" << root.u.int_value << std::endl;

    // 存储递归的Obj对象
    Obj* nested = new Obj;
    nested->u.int_value = 100;
    root.u.obj_ptr = nested;
    std::cout << "嵌套对象的整数：" << root.u.obj_ptr->u.int_value << std::endl;

    // 手动释放内存，避免泄漏
    delete nested;
    return 0;
}

这种方法简单直接，但要记得手动管理内存，不然容易出现内存泄漏问题。

2. 使用智能指针（现代C++推荐方案） #

如果想避免手动内存管理，推荐使用std::unique_ptr或std::shared_ptr这类智能指针，它们会自动释放内存，更安全也更符合现代C++的编程风格：

#include <iostream>
#include <memory>

struct Obj;

union RecursiveUnion {
    int int_value;
    std::unique_ptr<Obj> obj_ptr; // 用独占式智能指针
};

struct Obj {
    RecursiveUnion u;
};

int main() {
    Obj root;
    root.u.int_value = 42;
    std::cout << "存储的整数：" << root.u.int_value << std::endl;

    // 用make_unique创建嵌套对象，无需手动delete
    root.u.obj_ptr = std::make_unique<Obj>();
    root.u.obj_ptr->u.int_value = 100;
    std::cout << "嵌套对象的整数：" << root.u.obj_ptr->u.int_value << std::endl;

    // 程序结束时智能指针自动释放内存
    return 0;
}

额外提示：给联合加判别标签 #

判别式联合的核心是要有一个"标签"来标记当前union存储的是哪种类型，避免错误访问成员。你可以把标签和union封装在一起：

struct Obj;

struct TaggedUnion {
    // 标记当前存储的类型
    enum Type { INT_TYPE, OBJ_TYPE } tag;
    union {
        int int_value;
        std::unique_ptr<Obj> obj_ptr;
    } data;
};

struct Obj {
    TaggedUnion u;
};

使用时先检查tag的值，再访问对应的data成员，能避免未定义行为。

内容的提问来源于stack exchange，提问作者ale64bit