如何用C++模板合并功能相似但成员不同的Character与Monster类？

核心思路：模板+属性特征分离 #

不用依赖模板偏特化写重复代码，核心是把两个类的**差异点（属性映射、初始化逻辑）**抽离成独立的特征结构体，让通用模板类基于这些特征实现统一逻辑。

步骤1：定义属性特征类 #

将Character和Monster的属性规则、初始化逻辑封装到各自的特征结构体中，把所有差异集中在这里：

// Character的属性特征
struct CharacterTraits {
    // 战斗属性映射：攻击对应STR，防御对应DEX，魔法对应INT
    static int getAttack(const auto& obj) { return obj.getSTR(); }
    static int getDefense(const auto& obj) { return obj.getDEX(); }
    static int getMagic(const auto& obj) { return obj.getINT(); }

    // 初始化默认属性
    static void initMembers(auto& obj) {
        obj.setSTR(10);
        obj.setDEX(8);
        obj.setINT(12);
    }
};

// Monster的属性特征
struct MonsterTraits {
    static int getAttack(const auto& obj) { return obj.getATK(); }
    static int getDefense(const auto& obj) { return obj.getDEF(); }
    // Monster无魔法属性，返回0适配通用逻辑
    static int getMagic(const auto& obj) { return 0; }

    static void initMembers(auto& obj) {
        obj.setATK(15);
        obj.setDEF(10);
    }
};

步骤2：编写通用模板类 #

把getter/setter、战斗逻辑等通用代码放到模板类中，模板参数接收上面的特征类，所有依赖属性的逻辑都通过特征类转发：

#include <algorithm> // 用于std::max

template<typename Traits>
class Combatant {
private:
    // 统一存储属性，通过不同getter映射到Character/Monster的属性名
    int attr1; // 对应Character的STR / Monster的ATK
    int attr2; // 对应Character的DEX / Monster的DEF
    int attr3; // 对应Character的INT / Monster的无属性（留空）
    int hp = 100;

public:
    // Character专属getter/setter
    int getSTR() const { return attr1; }
    void setSTR(int val) { attr1 = val; }
    int getDEX() const { return attr2; }
    void setDEX(int val) { attr2 = val; }
    int getINT() const { return attr3; }
    void setINT(int val) { attr3 = val; }

    // Monster专属getter/setter
    int getATK() const { return attr1; }
    void setATK(int val) { attr1 = val; }
    int getDEF() const { return attr2; }
    void setDEF(int val) { attr2 = val; }

    // 通用HP接口
    int getHP() const { return hp; }
    void setHP(int val) { hp = std::max(0, val); }

    // 构造函数：通过特征类初始化属性
    Combatant() {
        Traits::initMembers(*this);
    }

    // 同类型战斗：通用逻辑，属性获取交给特征类
    void Fight(Combatant& target) {
        int myAttack = Traits::getAttack(*this);
        int targetDefense = Traits::getDefense(target);
        int damage = std::max(0, myAttack - targetDefense);
        damage += Traits::getMagic(*this) * 2; // 魔法伤害逻辑
        target.setHP(target.getHP() - damage);
    }

    // 跨类型战斗：模板支持不同特征的Combatant实例
    template<typename OtherTraits>
    void Fight(Combatant<OtherTraits>& target) {
        int myAttack = Traits::getAttack(*this);
        int targetDefense = OtherTraits::getDefense(target);
        int damage = std::max(0, myAttack - targetDefense);
        damage += Traits::getMagic(*this) * 2;
        target.setHP(target.getHP() - damage);
    }
};

步骤3：定义别名简化使用 #

用using给模板实例起直观的别名，调用时和原来的类完全一致：

using Character = Combatant<CharacterTraits>;
using Monster = Combatant<MonsterTraits>;

为什么不用模板偏特化？ #

偏特化确实需要编写两个独立代码块，但这是因为你之前没把差异点抽离成可复用的特征单元。上面的方案把属性映射、初始化等差异全部集中到特征类，模板类只负责通用逻辑，完全避免重复代码。

关于类设计的疑问 #

你的类设计本身没问题，这类"逻辑一致但属性细节不同"的场景，正是C++模板+特征类（Trait）的典型应用场景，完全可以做到零重复代码。之前觉得需要重复代码，只是没用到特征类这种模板编程技巧——它专门用来解决"同逻辑、不同配置"的问题。

额外优化：成员变量差异极大的情况 #

如果Character和Monster的成员变量完全不同（比如Character有背包，Monster有栖息地），可以把特有的成员放到特征类中，用组合方式让模板类持有特征类实例：

template<typename Traits>
class Combatant {
private:
    Traits unique_data; // 存储特有的成员变量
    int hp = 100;

public:
    // 转发特有的getter/setter
    int getSTR() const { return unique_data.getSTR(); }
    void setSTR(int val) { unique_data.setSTR(val); }
    int getATK() const { return unique_data.getATK(); }
    void setATK(int val) { unique_data.setATK(val); }

    // 通用战斗逻辑保持不变
    void Fight(Combatant& target) {
        int myAttack = Traits::getAttack(*this);
        // ... 同上逻辑
    }
};

// 特征类包含特有的成员
struct CharacterTraits {
    int str = 10;
    int dex = 8;
    int int_ = 12;
    std::vector<std::string> backpack; // Character专属背包

    int getSTR() const { return str; }
    void setSTR(int val) { str = val; }
    // ... 其他getter/setter
};

这样无论成员差异多大，模板类都能保持通用，所有特有内容都在特征类中，彻底消除重复代码。

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