C++多模板使用求助：代码无法编译，实现思路是否可行？

你的实现思路完全可行——用模板消除冗余的switch-case，实现建筑与单元的自由组合，核心逻辑没问题，但代码存在几个编译层面的问题，逐个修正即可：

1. 模板成员函数的声明缺失 #

C++要求类的模板成员函数必须先在类声明中声明，才能在类外定义。你当前的myclass类没有声明CreateBuilding和CreateUnit这两个模板成员函数，编译器找不到模板的声明，会直接报错。

修正：在myclass的类声明中添加模板函数声明：

class myclass {
public:
    template<class T_Building, class T_Unit>
    C_Building* CreateBuilding(char* inputdata);

    template<class T_Unit>
    C_Unit* CreateUnit(char* inputdata);
};

2. 基类模板成员函数的可见性问题 #

C_Building的LoadBuilding是模板成员函数，当通过基类指针pBuilding调用时，需要确保编译器能看到该模板的定义（或有显式实例化）。如果模板定义和类声明不在同一编译单元，会导致链接错误。

建议把LoadBuilding的定义放在C_Building类声明内部，确保可见性：

class C_Building {
public:
    template<class T_Unit>
    void LoadBuilding(char* inputdata) {
        C_Unit* pUnit;
        // 初始化建筑数据逻辑
        pUnit = myclass_Item->CreateUnit<T_Unit>(inputdata);
        // 其他单元相关逻辑
    }
};

3. myclass_Item的访问权限问题 #

在C_Building::LoadBuilding中使用myclass_Item指针，需要确保C_Building能访问到这个变量：

• 若myclass_Item是全局变量，需在C_Building定义前声明：extern myclass* myclass_Item;
• 若为成员变量，需将C_Building声明为myclass的友元，或通过myclass的接口获取实例。

4. 字符串字面量的类型不匹配 #

你传入的"some_data_to_load"是const char*类型，但函数参数是char*，C++不允许隐式转换const char*到char*，会触发编译错误。建议将所有函数的char*参数改为const char*：

// 修改myclass的CreateBuilding参数
template<class T_Building, class T_Unit>
C_Building* myclass::CreateBuilding(const char* inputdata) {
    // 逻辑不变
}

// 同步修改CreateUnit、LoadBuilding、LoadUnit的参数为const char*

修正后的完整示例片段 #

// 提前声明必要类
class C_Unit;
class C_Building;
class myclass;

// 全局实例声明（若使用全局变量）
extern myclass* myclass_Item;

class C_Unit {
public:
    void LoadUnit(const char* inputdata) {
        // 初始化单元数据
    }
};

class C_Building {
public:
    template<class T_Unit>
    void LoadBuilding(const char* inputdata) {
        C_Unit* pUnit;
        // 初始化建筑数据
        pUnit = myclass_Item->CreateUnit<T_Unit>(inputdata);
        // 单元相关逻辑
    }
};

class myclass {
public:
    template<class T_Building, class T_Unit>
    C_Building* CreateBuilding(const char* inputdata);

    template<class T_Unit>
    C_Unit* CreateUnit(const char* inputdata);
};

// myclass模板成员函数实现
template<class T_Building, class T_Unit>
C_Building* myclass::CreateBuilding(const char* inputdata) {
    C_Building* pBuilding = new T_Building();
    pBuilding->LoadBuilding<T_Unit>(inputdata);
    return pBuilding;
}

template<class T_Unit>
C_Unit* myclass::CreateUnit(const char* inputdata) {
    C_Unit* pUnit = new T_Unit();
    pUnit->LoadUnit(inputdata);
    // 单元相关操作
    return pUnit;
}

// 子类示例
class Building_House : public C_Building {};
class Building_Shop_A : public C_Building {};
class Unit_People : public C_Unit {};
class Unit_Vendor_A : public C_Unit {};

// 使用示例
int main() {
    myclass_Item = new myclass();
    C_Building* pBuilding1 = myclass_Item->CreateBuilding<Building_House, Unit_People>("some_data_to_load");
    C_Building* pBuilding2 = myclass_Item->CreateBuilding<Building_Shop_A, Unit_Vendor_A>("other_data_to_load");
    // 后续逻辑
    return 0;
}

额外优化建议 #

• 用智能指针（如std::unique_ptr）替代裸指针，避免内存泄漏：

  template<class T_Building, class T_Unit>
  std::unique_ptr<C_Building> myclass::CreateBuilding(const char* inputdata) {
      auto pBuilding = std::make_unique<T_Building>();
      pBuilding->LoadBuilding<T_Unit>(inputdata);
      return pBuilding;
  }
  

• 将myclass_Item封装为单例，通过myclass::GetInstance()静态方法获取，降低全局变量耦合。

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