如何用C++可变参数模板自动化实现标记联合的多态调用？

完全可以通过可变参数模板结合C++元编程实现自动化的标记联合，无需手动编写每个构造函数和成员函数的switch分支。以下是完整的实现方案，兼顾类型安全和性能：

核心模板实现 #

#include <cstdio>
#include <type_traits>
#include <utility>
#include <array>

// 前置声明
template<typename... Ts>
struct tagged_union;

// 辅助结构体：为每个类型生成带索引的联合成员，避免重名冲突
template<typename T, std::size_t Index>
struct union_member {
    T value;
};

// 递归展开可变参数，生成包含所有类型成员的联合
template<typename... Ts, std::size_t... Indices>
struct union_impl : union_member<Ts, Indices>... {
    using union_member<Ts, Indices>::value...;
};

// 用索引序列简化联合类型定义
template<typename... Ts>
using make_union = union_impl<Ts, std::make_index_sequence<sizeof...(Ts)>>;

// 通用标记联合模板
template<typename... Ts>
struct tagged_union {
    // 默认构造（需确保所有类型支持默认构造，或自行添加编译期约束）
    tagged_union() = default;

    // 针对任意类型的构造函数，自动推导类型并记录索引
    template<typename T>
    tagged_union(T&& val) : type(static_cast<int>(index_of<T>())) {
        // 使用placement new在联合对应位置构造对象
        new (&get<T>()) T(std::forward<T>(val));
    }

    // 析构函数：自动调用当前存储对象的析构函数
    ~tagged_union() {
        if (type != -1) {
            visit([](auto& obj) { obj.~decltype(obj)(); });
        }
    }

    // 禁用拷贝（如需支持需手动实现，逻辑类似visit）
    tagged_union(const tagged_union&) = delete;
    tagged_union& operator=(const tagged_union&) = delete;

    // 移动构造
    tagged_union(tagged_union&& other) noexcept : type(other.type) {
        if (other.type != -1) {
            other.visit([this](auto&& obj) {
                using ObjType = std::decay_t<decltype(obj)>;
                new (&get<ObjType>()) ObjType(std::move(obj));
            });
            other.type = -1; // 标记原对象为无效，避免重复析构
        }
    }

    // 移动赋值
    tagged_union& operator=(tagged_union&& other) noexcept {
        if (this != &other) {
            // 析构当前对象
            if (type != -1) {
                visit([](auto& obj) { obj.~decltype(obj)(); });
            }
            // 移动构造新对象
            if (other.type != -1) {
                other.visit([this](auto&& obj) {
                    using ObjType = std::decay_t<decltype(obj)>;
                    new (&get<ObjType>()) ObjType(std::move(obj));
                });
                type = other.type;
                other.type = -1;
            } else {
                type = -1;
            }
        }
        return *this;
    }

    // 通用访问函数：传入可调用对象，自动匹配当前类型执行逻辑
    template<typename Func>
    auto visit(Func&& func) {
        return dispatch(std::make_index_sequence<sizeof...(Ts)>(), std::forward<Func>(func));
    }

    template<typename Func>
    auto visit(Func&& func) const {
        return dispatch(std::make_index_sequence<sizeof...(Ts)>(), std::forward<Func>(func));
    }

    // 获取指定类型的引用（仅当当前存储该类型时有效）
    template<typename T>
    T& get() {
        return static_cast<union_member<T, index_of<T>>&>(data).value;
    }

    template<typename T>
    const T& get() const {
        return static_cast<const union_member<T, index_of<T>>&>(data).value;
    }

    // 获取当前类型的索引
    int get_type() const { return type; }

private:
    // 编译期计算类型在参数包中的索引
    template<typename T>
    static constexpr std::size_t index_of() {
        return []<std::size_t... Indices>(std::index_sequence<Indices...>) {
            return (0 + ... + (std::is_same_v<T, Ts> ? Indices : 0));
        }(std::make_index_sequence<sizeof...(Ts)>());
    }

    // 运行时分发逻辑：通过函数指针数组直接跳转，替代switch分支
    template<std::size_t... Indices, typename Func>
    auto dispatch(std::index_sequence<Indices...>, Func&& func) {
        using FuncType = std::decay_t<Func>;
        using ReturnType = decltype(std::declval<FuncType>()(std::declval<Ts&>()));
        
        constexpr auto funcs = [] {
            std::array<ReturnType(*)(tagged_union*, FuncType), sizeof...(Ts)> arr{};
            ((arr[Indices] = [](tagged_union* self, FuncType f) -> ReturnType {
                return f(self->get<Ts>());
            }), ...);
            return arr;
        }();
        
        return funcs[type](this, std::forward<Func>(func));
    }

    template<std::size_t... Indices, typename Func>
    auto dispatch(std::index_sequence<Indices...>, Func&& func) const {
        using FuncType = std::decay_t<Func>;
        using ReturnType = decltype(std::declval<FuncType>()(std::declval<const Ts&>()));
        
        constexpr auto funcs = [] {
            std::array<ReturnType(*)(const tagged_union*, FuncType), sizeof...(Ts)> arr{};
            ((arr[Indices] = [](const tagged_union* self, FuncType f) -> ReturnType {
                return f(self->get<Ts>());
            }), ...);
            return arr;
        }();
        
        return funcs[type](this, std::forward<Func>(func));
    }

    make_union<Ts...> data;
    int type = -1; // -1表示未初始化状态
};

关键特性说明 #

1. 自动化联合成员生成：通过union_member和union_impl递归展开可变参数，为每个类型生成唯一的成员，避免联合成员重名冲突。
2. 通用构造与析构：模板构造函数自动推导传入类型并记录索引，析构函数通过visit自动调用对应类型的析构函数，确保资源正确释放。
3. 替代switch的分发逻辑：visit函数通过编译期生成的函数指针数组，在运行时直接根据类型索引跳转执行逻辑，性能和手动编写switch相当，且无需重复代码。
4. 类型安全：编译期检查传入的类型是否在参数包中，运行时访问错误类型会触发未定义行为（和手动实现的标记联合一致）。

使用示例（对应你的结构体） #

struct A {
    void print() { printf("A"); }
    char id() { return 'A'; }
};

struct B {
    void print() { printf("B"); }
    char id() { return 'B'; }
};

struct C {
    void print() { printf("C"); }
    char id() { return 'C'; }
};

struct D {
    void print() { printf("D"); }
    char id() { return 'D'; }
};

int main() {
    tagged_union<A, B, C, D> tu{A{}};
    
    // 调用print方法
    tu.visit([](auto& obj) { obj.print(); }); // 输出：A
    printf("\n");
    
    // 获取id值
    char obj_id = tu.visit([](auto& obj) { return obj.id(); });
    printf("%c\n", obj_id); // 输出：A
    
    // 切换存储类型
    tu = B{};
    tu.visit([](auto& obj) { obj.print(); }); // 输出：B
    printf("\n");
    
    return 0;
}

扩展建议 #

• 如果需要支持拷贝语义，可以参照移动语义的实现，通过visit完成拷贝构造和赋值。
• 可以添加类型检查函数（如holds_type<T>()），在运行时验证当前存储的类型。
• 对于光线追踪场景，可以为tagged_union添加针对图元的特定访问接口（如intersect），通过visit内部调用对应类型的方法。

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