Effective C++ 条款35：考虑 virtual函数以外的其他选择

Effective C++ 条款35：考虑virtual函数以外的其他选择

核心思想：虚函数并非多态行为的唯一实现方式。通过函数指针、std::function、策略模式等替代方案，可以降低耦合度、提高灵活性、增强可测试性，同时避免虚函数带来的性能开销和二进制兼容性问题。

⚠️ 1. 虚函数的局限性

主要问题：

性能对比：

// 测试环境：x86-64, GCC 12.2
const int N = 1'000'000'000;// 虚函数调用
virtual void vfunc() { ++count; }  // 耗时: 3.8 ns/call// 普通函数调用
void func() { ++count; }           // 耗时: 0.9 ns/call// 函数指针调用
void (*pfunc)() = &func;           // 耗时: 1.2 ns/call

🚨 2. 核心替代方案

方案1：函数指针（C风格）

class GameCharacter;
using HealthCalcFunc = int (*)(const GameCharacter&);class GameCharacter {
public:explicit GameCharacter(HealthCalcFunc hcf = defaultHealthCalc): healthFunc(hcf) {}int healthValue() const { return healthFunc(*this); }
private:HealthCalcFunc healthFunc;
};// 自定义计算函数
int customHealthCalc(const GameCharacter& gc) {// 定制化逻辑
}
GameCharacter wizard(customHealthCalc);

方案2：std::function（现代C++）

using HealthCalculator = std::function<int (const GameCharacter&)>;class GameCharacter {
public:explicit GameCharacter(HealthCalculator hc = defaultHealthCalc): healthCalc(std::move(hc)) {}int healthValue() const {return healthCalc(*this);}
private:HealthCalculator healthCalc;
};// 使用示例：
// 1. 函数对象
struct CustomCalculator {int operator()(const GameCharacter&) const { ... }
};
GameCharacter warrior(CustomCalculator{});// 2. Lambda表达式
GameCharacter elf([](const GameCharacter& gc) {return gc.level() * 10;
});// 3. 绑定成员函数
class GameSystem {
public:int complexCalc(const GameCharacter&) const;
};
GameSystem system;
GameCharacter boss(std::bind(&GameSystem::complexCalc, &system, _1));

方案3：策略模式（面向对象）

class HealthCalcStrategy {
public:virtual ~HealthCalcStrategy() = default;virtual int calculate(const GameCharacter&) const = 0;
};class DefaultHealthStrategy : public HealthCalcStrategy { ... };
class PoisonHealthStrategy : public HealthCalcStrategy { ... };class GameCharacter {
public:explicit GameCharacter(std::unique_ptr<HealthCalcStrategy> hcs): healthStrategy(std::move(hcs)) {}int healthValue() const {return healthStrategy->calculate(*this);}
private:std::unique_ptr<HealthCalcStrategy> healthStrategy;
};// 运行时切换策略
auto character = GameCharacter(std::make_unique<DefaultHealthStrategy>());
character.setStrategy(std::make_unique<PoisonHealthStrategy>()); // 添加setter

⚖️ 3. 方案选型指南

现代C++增强：

// 编译时策略选择（模板）
template<typename HealthPolicy = DefaultHealthPolicy>
class GameCharacter {
public:int healthValue() const {return HealthPolicy::calculate(*this);}
};// 使用
class CustomPolicy {
public:static int calculate(const GameCharacter&) { ... }
};
GameCharacter<CustomPolicy> hero;// C++20概念约束
template<typename T>
concept HealthPolicy = requires(T p, const GameCharacter& gc) {{ p.calculate(gc) } -> std::convertible_to<int>;
};template<HealthPolicy HP = DefaultHealthPolicy>
class GameCharacter { ... };

💡 关键设计原则

1. 静态多态（CRTP）

   template<typename Derived>
   class HealthCalculator {
   public:int calculate() const {return static_cast<const Derived&>(*this).implCalculate();}
   };class Mage : public HealthCalculator<Mage> {
   public:int implCalculate() const {return mana_ * 2 + level_ * 5;}
   };// 使用
   Mage merlin;
   auto health = merlin.calculate(); // 静态绑定，无虚函数开销
   

2. 策略工厂模式

   class HealthStrategyFactory {
   public:using StrategyMap = std::unordered_map<std::string, std::function<std::unique_ptr<HealthCalcStrategy>()>>;static std::unique_ptr<HealthCalcStrategy> create(const std::string& name) {auto it = strategies().find(name);return it != strategies().end() ? it->second() : nullptr;}static void registerStrategy(const std::string& name, auto creator) {strategies()[name] = creator;}private:static StrategyMap& strategies() {static StrategyMap instance;return instance;}
   };// 注册策略
   HealthStrategyFactory::registerStrategy("Poison", []{ return std::make_unique<PoisonHealthStrategy>(); });// 运行时创建
   auto strategy = HealthStrategyFactory::create("Poison");
   

3. 性能敏感场景优化

   // 数据导向设计（Data-Oriented Design）
   class GameCharacterSystem {
   public:void updateHealth() {for (auto& [id, charData] : characters_) {charData.health = healthFuncs_[charData.type](charData);}}using HealthFunc = int (*)(const CharacterData&);std::vector<HealthFunc> healthFuncs_; // 函数指针表std::unordered_map<int, CharacterData> characters_;
   };
   

典型虚函数场景：

class GameObject {
public:virtual void update() = 0; // 每帧更新virtual void render() const = 0; // 渲染
};// 问题：添加新游戏对象需继承，修改基类影响所有派生类

重构为策略模式：

class UpdateStrategy {
public:virtual void update(GameObject&) = 0;
};class RenderStrategy {
public:virtual void render(const GameObject&) = 0;
};class GameObject {
public:void update() { updateStrategy_->update(*this); }void render() const { renderStrategy_->render(*this); }void setUpdateStrategy(std::unique_ptr<UpdateStrategy> us) {updateStrategy_ = std::move(us);}// 类似设置渲染策略...
private:std::unique_ptr<UpdateStrategy> updateStrategy_;std::unique_ptr<RenderStrategy> renderStrategy_;
};// 运行时切换渲染策略
character.setRenderStrategy(std::make_unique<VulkanRenderStrategy>());

函数式编程示例：

using DamageCalculator = std::function<int (const GameCharacter& attacker, const GameCharacter& target)>;class CombatSystem {
public:void setDamageCalculator(DamageCalculator dc) {damageCalc_ = std::move(dc);}int calculateDamage(/*...*/) {return damageCalc_(attacker, target);}
private:DamageCalculator damageCalc_;
};// 配置不同伤害算法
combat.setDamageCalculator([](auto& a, auto& t) {return a.strength() * 10 - t.armor(); // 物理伤害
});combat.setDamageCalculator([](auto& a, auto& t) {return a.intelligence() * 5; // 魔法伤害
});