C++模板类共享const方法的代码复用方案选型咨询

三种方案的优劣分析 #

方案1：独立Reader类（传引用调用） #

这种方案的问题很突出：

• 调用语法繁琐，每次调用read都要传入对象引用，完全破坏了原类的成员方法调用习惯；
• 为访问A/B的私有成员，必须将Reader声明为友元，大幅提升了类之间的耦合度；
• 无法设计为静态类，每次使用都要创建Reader对象，额外增加不必要的开销。
  不推荐使用。

方案2：Reader类存储引用（std::reference_wrapper） #

相比方案1，它解决了重复传参的问题，构造时传入一次对象即可多次调用read，但依然存在明显缺陷：

• 同样需要友元声明来访问私有成员，耦合度问题没有本质改善；
• 原类的接口被强制改变，用户无法再通过a.read()直接调用，必须额外创建Reader对象，使用体验下降明显。
  仅在完全无法修改原类接口的极端场景下可考虑，绝非最优解。

方案3：提取公共基类 #

这是三种方案中最贴合C++类设计习惯的选择，核心优势如下：

• 完全保留原类的调用接口，用户依然可以用a.read()直接调用，无任何学习成本；
• 代码复用逻辑清晰，公共方法和成员集中在基类，派生类可专注于自身独有的业务逻辑；
• 可以通过模板参数区分不同的派生类（如示例中用OtherType区分A和B），完美适配你提到的多模板参数场景。

需要修正原示例中的一个细节：基类的p如果是私有成员，派生类无法直接访问，实际使用时需要将其改为protected，或者提供protected的访问接口。另外，如果A和B不需要被当作基类的实例使用（即不需要多态），建议使用private继承来避免里氏替换原则的潜在问题，调整后的示例如下：

template <class DataType>
class base {
protected:
    DataType p;
public:
    auto read() const;
};

template <class DataType>
class A : private base<DataType> {
    using base<DataType>::read; // 将read方法暴露到public接口
public:
    // 其他方法和成员
};

template <class DataType>
class B : private base<DataType> {
    using base<DataType>::read;
public:
    // 其他方法和成员（与A不同）
};

其他可行方案 #

方案4：CRTP（奇异递归模板模式） #

CRTP是模板类代码复用的常用技巧，尤其适合这种“不同类共享相同逻辑但不需要多态”的场景。它通过让派生类继承以自身为模板参数的基类，实现代码复用的同时，避免基类需要适配派生类的模板参数：

// 混入类，提供read方法
template <typename Derived>
class ReaderMixin {
public:
    auto read() const {
        // 通过static_cast访问派生类的私有成员
        return static_cast<const Derived*>(this)->p;
    }
};

template <class DataType>
class A : public ReaderMixin<A<DataType>> {
    DataType p;
    // 允许混入类访问私有成员
    friend class ReaderMixin<A<DataType>>;
public:
    // 其他方法和成员
};

template <class DataType>
class B : public ReaderMixin<B<DataType>> {
    DataType p;
    friend class ReaderMixin<B<DataType>>;
public:
    // 其他方法和成员（与A不同）
};

这种方案的优势：

• 保持原类接口不变，调用方式依然是a.read()；
• 基类不需要知道派生类的具体模板参数，适配性更强；
• 编译期即可完成代码展开，无任何运行时开销。

方案5：非成员友元函数 #

如果能接受将read改为非成员函数，也可以通过友元函数实现复用：

// 通用的read函数
template <typename T>
auto read(const T& obj) {
    return obj.p;
}

template <class DataType>
class A {
    DataType p;
    // 声明友元，允许read函数访问私有成员
    template <typename T>
    friend auto read(const T&);
public:
    // 其他方法和成员
};

template <class DataType>
class B {
    DataType p;
    template <typename T>
    friend auto read(const T&);
public:
    // 其他方法和成员（与A不同）
};

调用方式变为read(a)，这种方案代码最简洁，但改变了原有的成员方法调用习惯，适合对接口形式要求不严格的场景。

总结 #

最优方案是方案3（基类继承）或方案4（CRTP）：

• 如果你的类之间有明确的公共属性（如示例中的DataType p），且希望公共成员集中管理，优先选择基类继承；
• 如果公共逻辑仅涉及方法，且希望基类更灵活（不需要适配派生类的模板参数），优先选择CRTP。

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