如何在结构体B中定义指向模板类型A的指针？

针对你的需求——在结构体B中定义指向模板结构体A的指针，且A的具体类型T在对象创建时确定，以下是几种可行方案：

方案1：将结构体B也定义为模板类型 #

让B的类型参数与A的类型参数绑定，保证指针类型严格匹配：

template <typename T>
struct A
{
    T t;
};

template <typename T>
struct B
{
    A<T>* a; // 指针类型与A的具体实例类型完全对应
};

// 使用示例
int main() {
    A<int> a_int;
    B<int> b;
    b.a = &a_int;

    A<std::string> a_str;
    B<std::string> b_str;
    b_str.a = &a_str;
    return 0;
}

特点：类型安全，无额外运行时开销；但每个不同的T都会生成独立的B模板实例，代码会有一定冗余。

方案2：通过非模板基类实现多态 #

给模板结构体A定义一个非模板基类，B中存储基类指针，以此兼容不同类型的A实例：

// 定义非模板基类，必须包含虚析构避免内存泄漏
struct ABase
{
    virtual ~ABase() = default;
};

template <typename T>
struct A : public ABase
{
    T t;
};

struct B
{
    ABase* a; // 基类指针可指向任意A<T>的实例
};

// 使用示例
int main() {
    A<int> a_int;
    B b;
    b.a = &a_int;

    // 可切换指向不同类型的A实例
    A<std::string> a_str;
    b.a = &a_str;

    // 访问具体类型成员时需用dynamic_cast做类型转换
    if (auto* a_ptr = dynamic_cast<A<int>*>(b.a)) {
        a_ptr->t = 42;
    }
    return 0;
}

特点：单个B实例可兼容所有A类型；但需要基类包含虚函数（至少虚析构），存在一定运行时开销，访问具体成员时需显式类型转换。

方案3：使用void*指针（不推荐） #

直接用void*存储指针，同时建议额外记录类型信息以避免转换错误：

#include <typeinfo>
template <typename T>
struct A
{
    T t;
};

struct B
{
    void* a;
    const std::type_info* type; // 记录指针指向的实际类型
};

// 使用示例
int main() {
    A<int> a_int;
    B b;
    b.a = &a_int;
    b.type = &typeid(A<int>);

    // 转换前必须检查类型，否则会导致未定义行为
    if (*b.type == typeid(A<int>)) {
        auto* a_ptr = static_cast<A<int>*>(b.a);
        a_ptr->t = 42;
    }
    return 0;
}

特点：极度灵活，但完全失去编译期类型检查，极易引发错误，仅在特殊场景下考虑使用。

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