隐式vs显式接口

Question

在下面的示例中,使用隐式接口(案例2和3;模板)与使用显式接口(案例1;指向抽象类的指针)的优缺点是什么？

代码不会改变:

class CoolClass
{
public:
  virtual void doSomethingCool() = 0;
  virtual void worthless() = 0;
};

class CoolA : public CoolClass
{
public:
  virtual void doSomethingCool()
  { /* Do cool stuff that an A would do */ }

  virtual void worthless()
  { /* Worthless, but must be implemented */ }
};

class CoolB : public CoolClass
{
public:
  virtual void doSomethingCool()
  { /* Do cool stuff that a B would do */ }

  virtual void worthless()
  { /* Worthless, but must be implemented */ }
};

情况1:一个非模板化的类,它接受一个提供显式接口的基类指针:

class CoolClassUser
{
public:  
  void useCoolClass(CoolClass * coolClass)
  { coolClass.doSomethingCool(); }
};

int main()
{
  CoolClass * c1 = new CoolA;
  CoolClass * c2 = new CoolB;

  CoolClassUser user;
  user.useCoolClass(c1);
  user.useCoolClass(c2);

  return 0;
}

情况2:模板类,其模板类型提供隐式接口:

template <typename T>
class CoolClassUser
{
public:  
  void useCoolClass(T * coolClass)
  { coolClass->doSomethingCool(); }
};

int main()
{
  CoolClass * c1 = new CoolA;
  CoolClass * c2 = new CoolB;

  CoolClassUser<CoolClass> user;
  user.useCoolClass(c1);
  user.useCoolClass(c2);

  return 0;
}

情况3:一个模板类,其模板类型提供了一个隐式接口(这次,不是从CoolClass派生的:

class RandomClass
{
public:
  void doSomethingCool()
  { /* Do cool stuff that a RandomClass would do */ }

  // I don't have to implement worthless()! Na na na na na!
};

template <typename T>
class CoolClassUser
{
public:  
  void useCoolClass(T * coolClass)
  { coolClass->doSomethingCool(); }
};

int main()
{
  RandomClass * c1 = new RandomClass;
  RandomClass * c2 = new RandomClass;

  CoolClassUser<RandomClass> user;
  user.useCoolClass(c1);
  user.useCoolClass(c2);

  return 0;
}

情况1要求传入useCoolClass()的对象是CoolClass的子对象(并实现无价值()).另一方面,情况2和3将采用具有doSomethingCool()函数的任何类.

如果代码的用户总是很好地继承CoolClass,那么Case 1就具有直观意义,因为CoolClassUser总是希望实现CoolClass.但是假设这个代码将是API框架的一部分,所以我无法预测用户是否想要子类化CoolClass或者推出他们自己的具有doSomethingCool()函数的类.

一些相关的帖子:

/sf/answers/508518531/

/sf/answers/508528261/

/sf/answers/560691071/

Answer 1

关于为什么您更喜欢案例 1，我想到了一些考虑因素：

• 如果CoolClass不是纯接口，即部分实现也是继承的（尽管您也可以为案例 2/3 提供它，例如以基类的形式）；
• 是否有理由CoolClassUser在二进制文件而不是标头中实现（这不仅是保护，还可能是代码大小、资源控制、集中错误处理等）；
• 如果您想存储指针并稍后使用它，那么情况 1 似乎也更好：(a) 将它们全部保存在同一个容器中更容易，(b) 您还需要存储实际的数据类型，并且对于案例 2/3，我想到的解决方案是借助模板包装器将其转换为“显式”接口（即案例 1）。

案例 2/3 可能更可取的原因：

• 如果您后来认为它worthless()现在有价值并开始使用它，那么在情况 2 中，您将收到未实现它的类的编译时错误。在情况 1 中，没有任何东西会提醒您真正实现这些函数，除非您运气好的话可能会出现运行时错误。
• Case2/3 可能具有稍微更好的性能，但代价是代码大小更大。

在某些情况下，这可能纯粹是个人喜好的问题，无论是您的还是您的用户。