C++中将模板类作为参数传入函数/类的实现方法

问题说明 #

本场景核心为探索C++开发中，如何将已实例化的模板类对象传入其他类或函数，调用其公开接口。
原示例代码存在多处编译错误，核心问题包括：

• Com类的write方法定义为无参数形式，但调用时传入了msg参数，函数签名不匹配
• transmitFrame方法中直接写Com.write(msg)属于语法错误：Com是类模板名称，不是已实例化的对象，无法直接调用成员方法
• main函数未声明int类型返回值，不符合C++标准语法
• 字符数组定义char[] msg语法错误，数组变量名需放在方括号前
• 未考虑已实例化的Com<8> myCom对象的传递路径，方法内无法访问外部实例

可选实现方案 #

方案1：成员函数模板接收Com实例 #

适合仅在调用transmitFrame方法时需要访问Com对象、不需要在类内长期持有Com实例的场景，不需要将整个Instruction类定义为模板，改动量最小。
修正后的可编译代码：

#include <cstdint>

template<uint8_t _bus>
class Com {
public:
    // 修正write方法签名，匹配msg参数传入逻辑
    uint8_t write(const char* /*msg*/) { 
        return _bus; // 内部基于模板参数_bus实现总线通信逻辑
    }
};

class Instruction
{
public:
    int member;
    // 将成员函数定义为模板，自动适配不同总线号的Com实例
    template<uint8_t bus>
    void transmitFrame(const char* msg, Com<bus>& com) { 
        member = com.write(msg);
    }
};

int main(){
    Com<8> myCom;
    Instruction myInstruction;
    const char msg[] = {'h', 'e', 'l', 'l', 'o'};
    // 调用时直接传入已实例化的myCom对象即可
    myInstruction.transmitFrame(msg, myCom);
    return 0;
}

注意：参数使用Com实例的引用传递，避免对象拷贝产生额外开销，保证通信实例状态一致

方案2：将Instruction定义为模板类，绑定固定Com类型 #

适合Instruction实例全程和固定总线号的Com对象强绑定的场景，不需要每次调用方法都重复传入Com对象。
实现代码：

#include <cstdint>

template<uint8_t _bus>
class Com {
public:
    uint8_t write(const char* /*msg*/) { 
        return _bus;
    }
};

// Instruction声明为模板类，接收总线号参数，绑定对应Com类型
template<uint8_t bus>
class Instruction
{
private:
    Com<bus>& m_com; // 类内持有Com实例的引用
public:
    int member;
    // 构造函数传入已实例化的Com对象
    Instruction(Com<bus>& com) : m_com(com) {}

    void transmitFrame(const char* msg) { 
        member = m_com.write(msg);
    }
};

int main(){
    Com<8> myCom;
    // 实例化Instruction时指定总线号，传入对应Com实例
    Instruction<8> myInstruction(myCom);
    const char msg[] = {'h', 'e', 'l', 'l', 'o'};
    myInstruction.transmitFrame(msg);
    return 0;
}

补充说明：“类模板无法被直接继承”是错误认知，类模板既可以被普通类继承（指定明确的模板参数即可），也可以被其他模板类继承，模板参数可逐层传递。

方案3：抽象接口类型擦除（无模板依赖方案） #

如果不希望Instruction类依赖任何模板参数，追求最大程度的解耦，可以先抽离Com类的公共行为作为抽象基类，通过基类指针/引用实现类型擦除，适配所有实现该接口的通信类。
实现代码：

#include <cstdint>

// 定义通信公共抽象接口
class ICom {
public:
    virtual uint8_t write(const char* msg) = 0;
    virtual ~ICom() = default;
};

template<uint8_t _bus>
class Com : public ICom {
public:
    uint8_t write(const char* /*msg*/) override { 
        return _bus;
    }
};

class Instruction
{
private:
    ICom& m_com;
public:
    int member;
    // 构造函数接收任意实现了ICom接口的对象引用
    Instruction(ICom& com) : m_com(com) {}

    void transmitFrame(const char* msg) { 
        member = m_com.write(msg);
    }
};

int main(){
    Com<8> myCom;
    Instruction myInstruction(myCom); // Com<8>隐式向上转型为ICom引用
    const char msg[] = {'h', 'e', 'l', 'l', 'o'};
    myInstruction.transmitFrame(msg);
    return 0;
}

该方案扩展性最强，后续新增其他总线类型、其他通信实现类时，不需要修改Instruction类的代码；仅有的开销是虚函数调用的少量运行时成本，可根据项目场景选择。

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