<分区>
在以下示例中，使用隐式接口(interface)(案例 2 和 3；模板)与使用显式接口(interface)(案例 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:采用基类指针的非模板类，该指针提供显式接口(interface):
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:模板类型提供隐式接口(interface)的模板类:
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:一个模板类，其模板类型提供了一个隐式接口(interface)(这次，不是从 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 的子对象(并实现 worthless())。另一方面，情况 2 和 3 将采用具有 doSomethingCool() 函数的任何类。
如果代码的用户总是很好地子类化 CoolClass，那么情况 1 很直观，因为 CoolClassUser 总是期望 CoolClass 的实现。但是假设这段代码将成为 API 框架的一部分，所以我无法预测用户是否想要子类化 CoolClass 或推出他们自己的具有 doSomethingCool() 函数的类。
一些相关的帖子:
https://stackoverflow.com/a/7264550/635125