c++ - C++ : code reuse in interface centric design 中的设计问题

Question

该项目有一个目标:使用以界面为中心的设计。基本上我们只声明公共(public)纯函数的类，并让真正的类继承自它们。

现在出现一个问题 - 如何重用实用函数？

这是一个例子:

class InterF1 {
  public:
    int f1() = 0;
    int g1() = 0;   
}; 

class InterF2 {
  public:
    int f2() = 0;
}; 

class C1: public InterF1 {
  public:
    int f1();
    int g1();
};


class C2: public InterF1, InterF2 {
  public:
    int f1();
    int g1();
    int f2();
};

当我实现 C1::f1() 和 C2::f1() 时，我发现这两个函数之间存在代码重复。我应该如何删除重复项？

这是我的想法:

1) 我可以像这样向接口(interface)类添加 protected :

class InterF1 {
  public:
    int f1() = 0;
    int g1() = 0;   
  protected:
    int util();
    int convenient_var_calculated_by_util;
}; 

在上面的设计中，C1::f1()和C2::f2()都可以调用util()。

2) 我可以抽象出一个新的接口(interface):

class UtilI {
    public:
      int util(int in_var) = 0;
};

本设计中，InterF1、C1、C2改为

class InterF1 {
  public:
    int f1(UtilI u) = 0;
    int g1() = 0;   
}; 

class C1: public InterF1 {
  public:
    int f1(UtilI u);
    int g1();
};


class C2: public InterF1, InterF2 {
  public:
    int f1(UtilI u);
    int g1();
    int f2();
};

并且 C1::f1() 和 C2::f1() 都调用 UtilI API。

解决方案 2 似乎更符合我们“以界面为中心”的目标，而且看起来确实更好。但我有一个担心，InterF1 和 InterF2 本身应该是比 UtilI 更高级别的抽象，后者更多的是实现细节，我是否混合了这两个级别？换句话说，如果稍后实现发生变化，我将需要回来再次更新 f1() 和 f2() 签名，这听起来不对。

解决方案 1 确实看起来很方便，但对我来说它看起来不那么“纯粹”，我在这里是不是太教条了？

Answer 1

通常我会说您应该将通用实现放在基类中——但您要求基类是纯虚拟的。所以我建议:

1. 创建中间实现类

   如果每个想要实现 InterF2 的类也想要实现 InterF1，这种方法是可行的。

   方法是实现

   class InterF1Impl: public InterF1 {
     public:
       int f1();
       int g1();
   }
   

   然后 C1 和 C2 都可以派生自 InterF1Impl，它实现了通用的 f1() 和 g1() 方法。

   但是，如果您有另一个类 C3 : public InterF2，它希望与 共享 f2() 的实现，则此方法无法很好地扩展>C2 但不想实现 InterF1。

   另一种(更好的)方法是

2. 使用组合来包含一个实现类。

   在这种方法中，如上所述实现InterF1Impl: public InterF1，但不是派生 C1: public InterF1Impl，让InterF1Impl 成为 C1 类的一部分。

   class C1: public InterF1 {
     private:
       InterF1Impl * f1impl;
     public:
       int f1();
       int g1();
   }
   

   C1::f1() 和C1::g1() 方法简单地从f1impl 调用相应的方法。

   这样，如果你需要f2()的通用实现，那么你也可以实现InterF2: public InterF2，和C2可以用类似的方式实现:

   class C2: public InterF1, InterF2 {
     private:
       InterF1Impl * f1impl;
       InterF2Impl * f2impl;
     public:
       int f1(); /* calls f1impl->f1() */
       int g1(); /* calls f1impl->g1() */
       int f2(); /* calls f2impl->f2() */
   }
   

   另一个类可以只使用 InterF2 的实现，而无需同时实现 InterF1，如果您以后需要这样一个类的话。