C++变参模板如何访问vector中pair元素并实现自定义类C

你当前的代码框架有3个硬伤，无法通过编译，也满足不了实例化要求：

• Pair的模板参数定义错误：你要实现的是Pair<"x", A<int>>这种「编译期字符串+类型」的组合，不是两个类型参数的组合，必须用非类型模板参数承接字符串字面量。
• 成员变量tuple<Pair*...> v写法非法：Pair是类模板，不指定具体模板参数时不是完整类型，无法作为指针的基类型；且std::tuple是定长容器，本身没有push_back方法，和你要顺序存储所有参数包元素的需求不匹配。
• 不同Pair实例的value类型完全不同（比如A<int>、A<double>、B<int>都是独立类型），普通同质容器（比如std::vector）无法直接存储不同类型的元素，必须做类型擦除处理。

以下实现完全匹配你给出的main函数实例化写法，基于C20（直接用字符串字面量作为模板参数是C20才支持的特性）：

#include <iostream>
#include <vector>
#include <variant>
#include <string_view>
#include <stdexcept>

// 基础A、B类，可自行补充内部逻辑
template <typename X>
class A {
public:
    void print() const {
        std::cout << "A<" << typeid(X).name() << ">\n";
    }
};

template <typename Y>
class B {
public:
    void print() const {
        std::cout << "B<" << typeid(Y).name() << ">\n";
    }
};

// 编译期固定字符串工具，用于承接字符串字面量模板参数
template <std::size_t N>
struct FixedString {
    char data[N]{};
    constexpr FixedString(const char(&str)[N]) {
        for (std::size_t i = 0; i < N; ++i) data[i] = str[i];
    }
    constexpr operator std::string_view() const { return {data, N - 1}; }
    constexpr bool operator==(const FixedString&) const = default;
};

// 修正后的Pair定义，支持Pair<"x", A<int>>写法
template <FixedString Key, typename T>
struct Pair {
    static constexpr std::string_view key = Key;
    T value{};
};

template <typename... Pairs>
class C {
private:
    // 用std::variant做类型安全的类型擦除，覆盖所有可能的Pair类型
    using ElementType = std::variant<Pairs...>;
    std::vector<ElementType> storage;
public:
    C() {
        // 折叠表达式按参数包顺序，把所有Pair默认构造后存入容器
        (storage.emplace_back(Pairs{}), ...);
    }

    void func() {
        // 遍历所有存储的Pair元素
        for (auto& elem : storage) {
            // visit自动匹配Pair的实际类型，直接访问key和value
            std::visit([](auto& pair) {
                std::cout << "Current key: " << pair.key << ", value type: ";
                pair.value.print(); // 替换成你自己的value操作逻辑
            }, elem);
        }
    }

    // 按key获取对应value的示例方法
    template <FixedString TargetKey, typename TargetType>
    TargetType& get() {
        for (auto& elem : storage) {
            using TargetPair = Pair<TargetKey, TargetType>;
            if (auto ptr = std::get_if<TargetPair>(&elem)) {
                return ptr->value;
            }
        }
        throw std::runtime_error("key not exist");
    }
};

// 你给出的main实例化代码无需任何修改即可运行
int main()
{
  C<Pair<"x", A<int>>, Pair<"y", A<double>>, Pair<"z", B<int>>> c1;
  C<Pair<"x", A<int>>, Pair<"y", A<double>>> c2;
  c1.func();
  // 示例：获取c1中key为x的A<int>类型值
  auto& x_val = c1.get<"x", A<int>>();
  return 0;
}

• 类型擦除选型用std::variant而不是虚函数继承的原因是：所有要存储的Pair类型在C类实例化时已经完全确定，variant是类型安全的，没有虚函数的额外开销，编译器会在编译期做全量类型检查。
• 参数包展开用C++17引入的折叠表达式，不需要写递归模板特例化，一行代码就能按顺序把所有Pair实例追加到vector中。
• 访问元素时通过std::visit自动匹配variant中存储的实际Pair类型，不需要手动写类型判断分支，拿到pair实例后可以直接访问静态常量key和成员value。
• 如果需要兼容C17及更早版本（不支持C20的类类型非类型模板参数），可以把字符串key改成Pair的构造参数，用宏封装Pair的实例化逻辑，类型擦除部分可以换成公共基类+std::unique_ptr的方案，只是会损失一部分编译期检查能力。

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