如何在非模板类A中存储不同模板参数的B类对象？

这个问题的核心在于：B<int>和B<char>是完全不同的C++类型，你原来写的vector<B>（本身写法就有问题，因为B是模板类，必须指定参数才能作为具体类型）根本没法同时容纳这两类对象。下面给你几个实用的解决方案，按需选择：

方案1：多态基类 + 智能指针（经典C++多态方案） #

这种方法适合需要对所有B<T>对象执行统一操作的场景，比如都要调用某个方法。

首先定义一个非模板的基类，让所有B<T>都继承它：

#include <vector>
#include <memory>
#include <iostream>

// 定义非模板基类，提供统一接口
class BBase {
public:
    // 必须加虚析构，确保多态销毁时不会内存泄漏
    virtual ~BBase() = default;
    // 定义纯虚函数，让子类实现各自的逻辑
    virtual void printMember() const = 0;
};

// 修改模板类B，继承自BBase
template <class T>
class B : public BBase {
public:
    T member;
    // 实现基类的纯虚函数
    void printMember() const override {
        std::cout << "Member value: " << member << std::endl;
    }
};

// 修改类A的容器，存储基类的智能指针
class A {
public:
    std::vector<std::unique_ptr<BBase>> arr;
};

使用示例：

int main() {
    A container;
    // 创建不同类型的B对象，用智能指针管理
    auto b1 = std::make_unique<B<int>>();
    b1->member = 42;
    auto b2 = std::make_unique<B<char>>();
    b2->member = 'a';
    
    // 存入容器（注意用std::move转移所有权）
    container.arr.push_back(std::move(b1));
    container.arr.push_back(std::move(b2));
    
    // 遍历容器，统一调用printMember
    for (const auto& ptr : container.arr) {
        ptr->printMember();
    }
    return 0;
}

优缺点：

• 优点：符合C++经典多态设计，能统一操作所有B<T>对象，扩展性好（新增B<double>只需要继承基类实现接口）。
• 缺点：必须用指针/智能指针存储，不能直接存对象；如果要访问具体T类型的成员，需要用dynamic_cast，比较繁琐。

方案2：std::variant（C++17+，类型安全的多类型存储） #

如果你提前知道所有要存储的B<T>类型，用std::variant是更简洁的选择，它能在一个容器里存多种类型的对象，且类型完全安全。

#include <vector>
#include <variant>
#include <iostream>

template <class T>
class B {
public:
    T member;
};

// 定义variant类型，包含所有要存储的B<T>类型
using BVariant = std::variant<B<int>, B<char>>;

class A {
public:
    std::vector<BVariant> arr;
};

使用示例：

int main() {
    A container;
    B<int> b1{42};
    B<char> b2{'a'};
    
    // 直接存入容器，不需要指针
    container.arr.push_back(b1);
    container.arr.push_back(b2);
    
    // 用std::visit访问不同类型的对象
    for (auto& var : container.arr) {
        std::visit([](auto& b_obj) {
            std::cout << "Member value: " << b_obj.member << std::endl;
        }, var);
    }
    return 0;
}

优缺点：

• 优点：不需要指针，直接存对象；类型安全，编译时就能检查错误；访问时用std::visit可以优雅处理不同类型。
• 缺点：必须提前声明所有要支持的B<T>类型，如果要动态支持任意类型，这个方案不适用。

方案3：std::any（C++17+，任意类型存储） #

如果需要支持任意类型的B<T>，甚至不确定未来会加哪些类型，std::any可以满足需求，但类型安全性稍弱，访问时需要手动判断类型。

#include <vector>
#include <any>
#include <iostream>

template <class T>
class B {
public:
    T member;
};

class A {
public:
    std::vector<std::any> arr;
};

使用示例：

int main() {
    A container;
    B<int> b1{42};
    B<char> b2{'a'};
    B<double> b3{3.14}; // 新增类型也能直接存
    
    container.arr.push_back(b1);
    container.arr.push_back(b2);
    container.arr.push_back(b3);
    
    // 访问时需要用any_cast判断类型
    for (auto& item : container.arr) {
        if (const auto* b_int = std::any_cast<B<int>>(&item)) {
            std::cout << "Int member: " << b_int->member << std::endl;
        } else if (const auto* b_char = std::any_cast<B<char>>(&item)) {
            std::cout << "Char member: " << b_char->member << std::endl;
        } else if (const auto* b_double = std::any_cast<B<double>>(&item)) {
            std::cout << "Double member: " << b_double->member << std::endl;
        }
    }
    return 0;
}

优缺点：

• 优点：完全灵活，能存任意类型的B<T>，不需要提前声明。
• 缺点：访问时需要手动判断类型，容易出错；编译时无法检查类型错误，运行时如果类型不匹配会返回空指针。

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