如何用C++模板替代宏实现依赖枚举的类型实例化

问题背景 #

原有宏代码可根据AB枚举的运行时值，动态创建A或B结构体的嵌套类型（如X/Y/Z）实例，并返回对应的std::variant对象。现需将宏替换为标准C++模板代码，同时支持非默认构造的嵌套类型（如Y需要传入std::string参数），但最初尝试的模板写法无法正常工作。

原尝试模板代码的问题 #

最初的模板代码错误地将Attribute作为类型参数传入，但A::Attribute并非合法语法——模板参数Attribute是一个类型，而不是A的嵌套类型名称。宏是靠预处理器字符串替换实现的类型名称映射，模板无法直接复用这种逻辑。

可行实现方案 #

以下两种方案均支持完美转发构造参数，适配默认/非默认构造的嵌套类型，且具备编译期类型安全性。

方案一：标签类型+元函数映射 #

通过定义标签结构体标识嵌套类型，配合元函数实现外部类型与嵌套类型的映射，最终通过模板函数完成动态创建：

#include <variant>
#include <utility>
#include <string>

struct A {
    struct X{};
    struct Y { Y(std::string) {} }; // 非默认构造
    struct Z{};
};

struct B {
    struct X{};
    struct Y { Y(std::string) {} }; // 非默认构造
    struct Z{};
};

enum class AB { a, b };

// 定义嵌套类型对应的标签
struct X_tag {};
struct Y_tag {};
struct Z_tag {};

// 元函数：根据外部类型和标签获取对应的嵌套类型
template<typename Outer, typename Tag>
struct get_inner_type;

template<typename Outer>
struct get_inner_type<Outer, X_tag> { using type = typename Outer::X; };

template<typename Outer>
struct get_inner_type<Outer, Y_tag> { using type = typename Outer::Y; };

template<typename Outer>
struct get_inner_type<Outer, Z_tag> { using type = typename Outer::Z; };

// 简化类型别名
template<typename Outer, typename Tag>
using get_inner_type_t = typename get_inner_type<Outer, Tag>::type;

// 核心模板函数：支持完美转发构造参数
template<typename Tag, typename... Args>
std::variant<get_inner_type_t<A, Tag>, get_inner_type_t<B, Tag>>
access(AB ab, Args&&... args) {
    if (ab == AB::a) {
        return get_inner_type_t<A, Tag>(std::forward<Args>(args)...);
    } else {
        return get_inner_type_t<B, Tag>(std::forward<Args>(args)...);
    }
}

// 使用示例
int main() {
    AB ab = AB::a;
    // 创建默认构造的X实例
    std::variant<A::X, B::X> v_x = access<X_tag>(ab);
    // 创建需要参数的Y实例
    std::variant<A::Y, B::Y> v_y = access<Y_tag>(ab, "test_string");
}

方案二：模板模板参数 #

通过定义模板别名映射外部类型到嵌套类型，直接将该模板作为参数传入核心函数：

#include <variant>
#include <utility>
#include <string>

struct A {
    struct X{};
    struct Y { Y(std::string) {} };
    struct Z{};
};

struct B {
    struct X{};
    struct Y { Y(std::string) {} };
    struct Z{};
};

enum class AB { a, b };

// 模板别名：将外部类型映射到对应的嵌套类型
template<typename Outer>
using X_t = typename Outer::X;

template<typename Outer>
using Y_t = typename Outer::Y;

template<typename Outer>
using Z_t = typename Outer::Z;

// 核心模板函数：支持完美转发构造参数
template<template<typename> typename InnerType, typename... Args>
std::variant<InnerType<A>, InnerType<B>> access(AB ab, Args&&... args) {
    if (ab == AB::a) {
        return InnerType<A>(std::forward<Args>(args)...);
    } else {
        return InnerType<B>(std::forward<Args>(args)...);
    }
}

// 使用示例
int main() {
    AB ab = AB::b;
    // 创建默认构造的X实例
    std::variant<A::X, B::X> v_x = access<X_t>(ab);
    // 创建需要参数的Y实例
    std::variant<A::Y, B::Y> v_y = access<Y_t>(ab, std::string("hello_world"));
}

方案优势 #

• 类型安全：编译期即可检查嵌套类型是否存在、构造参数是否匹配，避免宏的预处理器替换带来的隐式错误
• 扩展性强：新增嵌套类型时，只需添加对应的标签或模板别名，无需修改核心函数
• 支持复杂构造：通过完美转发适配任意参数的构造函数，覆盖默认/非默认构造场景

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