C++中不污染类接口的同一成员函数多实现最佳架构问询

这个需求太常见了——既要保持类的接口清爽不被各种Add1()、Add2()污染，又能灵活测试不同实现的性能，还得把所有实现都保留下来。我给你整理几个C++里非常实用的优雅方案，你可以根据自己的场景选：

方案1：策略模式（Strategy Pattern）—— 动态切换实现 #

策略模式的核心是把不同的函数实现封装成独立的"策略类"，让主类通过持有策略对象来调用对应实现，完全不污染主类接口。

代码示例 #

#include <iostream>

// 策略基类，定义统一接口
struct AddStrategy {
    virtual void apply(int& value) const = 0;
    virtual ~AddStrategy() = default;
};

// 不同的实现策略
struct Add1 : AddStrategy {
    void apply(int& value) const override { value += 1; }
};

struct Add10 : AddStrategy {
    void apply(int& value) const override { value += 10; }
};

struct Add100 : AddStrategy {
    void apply(int& value) const override { value += 100; }
};

class Foo {
private:
    int val = 0;
    const AddStrategy* current_strategy = &default_strategy;
    static inline Add1 default_strategy; // 默认用加1的实现
public:
    void Print() const {
        std::cout << "Current value: " << val << std::endl;
    }

    // 默认调用当前策略的实现
    void Add() const {
        current_strategy->apply(const_cast<int&>(val));
    }

    // 切换默认策略，方便批量测试
    void set_strategy(const AddStrategy& strategy) {
        current_strategy = &strategy;
    }

    // 直接调用指定策略，无需切换默认值
    template<typename Strategy>
    void AddWith() {
        Strategy{}(val);
    }
};

int main() {
    Foo foo;
    foo.Print();
    foo.Add(); // 默认加1
    foo.Print();

    foo.AddWith<Add10>(); // 调用加10的实现
    foo.Print();

    foo.AddWith<Add100>(); // 调用加100的实现
    foo.Print();

    // 切换默认策略后，Add会持续使用新实现
    Add100 strategy3;
    foo.set_strategy(strategy3);
    foo.Add();
    foo.Print();

    return 0;
}

优缺点 #

• ✅ 完全不污染Foo的对外接口，所有实现都独立封装
• ✅ 支持运行时动态切换策略，适合需要频繁切换测试的场景
• ✅ 扩展新实现只需新增策略类，符合开闭原则
• ❌ 虚函数调用有微小的运行时开销（性能敏感场景可忽略，或用模板版本的AddWith避免）

方案2：CRTP（奇异递归模板模式）—— 静态多态无开销 #

如果你的场景对性能要求极高，不想有虚函数的开销，可以用CRTP实现静态多态，把不同实现放到独立的基类中。

代码示例 #

#include <iostream>

// CRTP基类，每个类对应一个Add实现
template<typename Derived>
struct AddImpl1 {
    void Add() {
        static_cast<Derived*>(this)->val += 1;
    }
};

template<typename Derived>
struct AddImpl2 {
    void Add() {
        static_cast<Derived*>(this)->val += 10;
    }
};

template<typename Derived>
struct AddImpl3 {
    void Add() {
        static_cast<Derived*>(this)->val += 100;
    }
};

// Foo继承所有实现基类，把val设为protected让基类访问
class Foo : public AddImpl1<Foo>, public AddImpl2<Foo>, public AddImpl3<Foo> {
protected:
    int val = 0;
public:
    void Print() const {
        std::cout << "Current value: " << val << std::endl;
    }

    // 默认Add指向其中一个实现（比如AddImpl1）
    void Add() {
        AddImpl1<Foo>::Add();
    }
};

int main() {
    Foo foo;
    foo.Print();
    foo.Add(); // 默认加1
    foo.Print();

    foo.AddImpl2<Foo>::Add(); // 调用加10的实现
    foo.Print();

    foo.AddImpl3<Foo>::Add(); // 调用加100的实现
    foo.Print();

    return 0;
}

优缺点 #

• ✅ 完全没有运行时开销，编译期就确定调用的实现
• ✅ 实现结构清晰，每个版本的Add都在独立的基类中
• ❌ Foo需要继承多个基类，且val需设为protected（比你原来的友元方案更优雅）
• ❌ 不支持运行时动态切换，只能在代码中显式指定调用哪个基类的实现

方案3：命名空间隔离实现—— 完全解耦类与逻辑 #

如果想让实现和Foo完全解耦，可以把不同的Add实现放到独立的命名空间中，通过非成员函数操作Foo的状态。

代码示例 #

#include <iostream>

class Foo {
private:
    int val = 0;
public:
    void Print() const {
        std::cout << "Current value: " << val << std::endl;
    }

    // 提供状态访问接口（或把实现函数设为友元，避免暴露get_val）
    int& get_val() { return val; }
    int get_val() const { return val; }
};

// 用命名空间隔离所有Add实现
namespace AddVersions {
    void Add1(Foo& foo) {
        foo.get_val() += 1;
    }

    void Add10(Foo& foo) {
        foo.get_val() += 10;
    }

    void Add100(Foo& foo) {
        foo.get_val() += 100;
    }
}

// 可选：给Foo加一个模板方法，包装命名空间里的实现
class Foo {
private:
    int val = 0;
public:
    void Print() const {
        std::cout << "Current value: " << val << std::endl;
    }

    template<typename Func>
    void Add(Func func) {
        func(*this);
    }

    int& get_val() { return val; }
    int get_val() const { return val; }
};

int main() {
    Foo foo;
    foo.Print();
    // 直接调用命名空间里的实现
    AddVersions::Add1(foo);
    foo.Print();

    AddVersions::Add10(foo);
    foo.Print();

    AddVersions::Add100(foo);
    foo.Print();

    // 用模板Add方法简化调用
    foo.Add(AddVersions::Add1);
    foo.Print();

    return 0;
}

优缺点 #

• ✅ 实现与Foo完全解耦，类接口极度干净
• ✅ 新增实现只需在命名空间里加函数，完全不影响Foo的代码
• ✅ 容易单独测试每个实现的性能
• ❌ 需要暴露Foo的状态访问接口（或使用友元，权衡封装性）
• ❌ 调用时需要写命名空间（可通过using AddVersions::Add1简化）

方案4：模板标签切换—— 编译期绑定实现 #

如果不需要运行时切换，只想在编译期指定或切换实现，可以用模板标签的方式，让Foo根据标签选择对应的实现。

代码示例 #

#include <iostream>

// 定义不同的实现标签
struct Add1Tag {};
struct Add10Tag {};
struct Add100Tag {};

// Foo是模板类，默认用Add1Tag
template<typename Tag = Add1Tag>
class Foo {
private:
    int val = 0;

    // 模板特化实现不同的Add逻辑
    void AddImpl(Add1Tag) { val += 1; }
    void AddImpl(Add10Tag) { val += 10; }
    void AddImpl(Add100Tag) { val += 100; }
public:
    void Print() const {
        std::cout << "Current value: " << val << std::endl;
    }

    // 默认Add调用绑定到模板标签的实现
    void Add() {
        AddImpl(Tag{});
    }

    // 允许调用其他标签的实现
    template<typename OtherTag>
    void AddAs() {
        AddImpl(OtherTag{});
    }
};

int main() {
    // 默认用Add1实现的Foo
    Foo<> foo;
    foo.Print();
    foo.Add();
    foo.Print();

    // 调用Add10的实现
    foo.AddAs<Add10Tag>();
    foo.Print();

    // 调用Add100的实现
    foo.AddAs<Add100Tag>();
    foo.Print();

    // 直接创建使用Add10实现的Foo实例
    Foo<Add10Tag> foo10;
    foo10.Add();
    foo10.Print();

    return 0;
}

优缺点 #

• ✅ 完全无运行时开销，编译期确定调用逻辑
• ✅ 可以在同一个实例上调用不同实现（通过AddAs），也可以创建绑定不同实现的实例
• ❌ 不支持运行时动态切换，所有实现选择都在编译期完成
• ❌ Foo变成模板类，可能会增加代码复杂度（如果不需要模板的其他特性）

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