[翻译] Effective C++, 3rd Edition, Item 41: 理解 implicit interfaces（隐式接口）和 compile-time polymorphism（编译期多态）

Item 41: 理解 implicit interfaces（隐式接口）和 compile-time polymorphism（编译期多态）

作者：Scott Meyers

译者：fatalerror99 (iTePub's Nirvana)

发布：http://blog.csdn.net/fatalerror99/

Object-Oriented Programming（面向对象编程）的世界是围绕着 explicit interfaces（显式接口）和 runtime polymorphism（执行期多态）为中心的。例如，给出下面这个（没有什么意义的）class（类），

class Widget {
public:
  Widget();
  virtual ~Widget();
  virtual std::size_t size() const;
  virtual void normalize();
  void swap(Widget& other);                 // see Item 25

  ...
};

以及这个（同样没有什么意义的）function（函数），

void doProcessing(Widget& w)
{
  if (w.size() > 10 && w != someNastyWidget) {
      Widget temp(w);
      temp.normalize();
      temp.swap(w);
  }
}

我们可以这样谈论 doProcessing 中的 w：

• 因为 w 被声明成类型 Widget，则 w 必须支持 Widget interface（接口）。我们可以在源代码中找到这个 interface（接口）（例如，Widget 的 .h 文件）以看清楚它是什么样子的，所以我们称其为一个 explicit interface（显式接口）——它在源代码中显式可见。

• 因为 Widget 的一些 member functions（成员函数）是虚拟的，w 对这些函数的调用就表现为 runtime polymorphism（执行期多态）：被调用的特定函数在执行期基于 w 的 dynamic type（动态类型）来确定（参见 Item 37）。

templates（模板）和 generic programming（泛型编程）的世界是根本不同的。在那个世界，explicit interfaces（显式接口）和 runtime polymorphism（执行期多态）继续存在，但是它们不那么重要了。反而，implicit interfaces（隐式接口）和 compile-time polymorphism（编译期多态）移到了前台。为了了解这是怎样一种情况，看一下当我们把 doProcessing 从一个 function（函数）变成一个 function template（函数模板）时会发生什么：

template<typename T>
void doProcessing(T& w)
{
  if (w.size() > 10 && w != someNastyWidget) {
     T temp(w);
     temp.normalize();
     temp.swap(w);
  }
}

现在我们可以如何谈论 doProcessing 中的 w 呢？

• w 必须支持的 interface（接口）是通过 template（模板）中在 w 身上所执行的操作确定的。在本例中，它显现为 w 的类型 (T) 必须支持 size，normalize 和 swap member functions（成员函数）；copy construction（拷贝构造函数）（用于创建 temp）；以及对不等于的比较（用于和 someNastyWidget 之间的比较）。我们将在以后看到这并不很精确，但是对于现在来说它已经足够正确了。重要的是这一系列为了模板能够编译必须合法的表达式就是 T 必须支持的 implicit interface（隐式接口）。

• 对诸如 operator> 和 operator!= 这样的涉及 w 的函数的调用可能伴随 instantiating templates（实例化模板）以使这些调用成功。这样的 instantiation（实例化）发生在编译期间。因为用不同的 template parameters（模板参数）实例化 function templates（函数模板）导致不同的函数被调用，因此以 compile-time polymorphism（编译期多态）闻名。

即使你从没有使用过模板，你也应该熟悉 runtime（运行期）和 compile-time polymorphism（编译期多态）之间的区别，因为它类似于确定一系列重载函数中哪一个应该被调用的过程（这个发生在编译期）和 virtual function（虚拟函数）调用的 dynamic binding（动态绑定）（这个发生在运行期）之间的区别。explicit（显式）和 implicit interfaces（隐式接口）之间的区别是与 templates（模板）有关的新内容，需要对他进行近距离的考察。

一个 explicit interface（显式接口）一般由 function signatures（函数识别特征）组成，也就是说，函数名，参数类型，返回类型，等等。例如，Widget class（类）的 public interface（公有接口），

class Widget {
public:
  Widget();
  virtual ~Widget();
  virtual std::size_t size() const;
  virtual void normalize();
  void swap(Widget& other);
};

由一个 constructor（构造函数），一个 destructor（析构函数），以及函数 size，normalize 和 swap 组成，再加上 parameter types（参数类型），return types（返回类型）和这些函数的 constnesses（常量性）。（它也包括 compiler-generated（编译器生成）的 copy constructor（拷贝构造函数）和 copy assignment operator（拷贝赋值运算符）——参见 Item 5。）它还可能包含 typedefs，还有，如果你胆大包天敢于违背 Item 22 的让 data members（数据成员）private（私有）的建议，那就包括 data members（数据成员），虽然在当前情况下，它不是。

一个 implicit interface（隐式接口）有很大不同。它不是基于 function signatures（函数识别特征）的。它是由 valid expressions（合法表达式）组成的。再看一下在 doProcessing template 开始处的条件：

template<typename T>
void doProcessing(T& w)
{
  if (w.size() > 10 && w != someNastyWidget) {
  ...

对于 T（w 的类型）的 implicit interface（隐式接口）看起来有如下这些约束：

• 它必须提供一个名为 size 的返回一个整数值的 member function（成员函数）。

• 它必须支持一个用于比较两个类型 T 的对象的 operator!= 函数。（这里，我们假定 someNastyWidget 的类型为 T。）

由于 operator overloading（运算符重载）的可能性，这两个约束都不必满足。是的，T 必须支持一个 size member function（成员函数），可是值得一提的是这个函数可以是从一个 base class（基类）继承来的。但是这个 member function（成员函数）不必返回一个整数类型。它甚至不必返回一个数值类型。对于这种情况，它甚至不必返回一个定义了 operator> 的类型！它要做的全部就是返回某种类型 X 的一个 object（对象），存在一个可以由一个类型 X 的 object（对象）和一个 int（因为 10 为 int 类型）来调用的 operator>。这个 operator> 不一定非要取得一个类型 X 的参数，因为只要存在一个从类型 X 的 objects（对象）到类型 Y 的 objects（对象）的 implicit conversion（隐式转型），它只取得一个类型 Y 的参数也是可以的！

类似地，T 支持 operator!= 也是没有必要的，因为正像 operator!= 取得一个类型 X 的 objects（对象）和一个类型 Y 的 objects（对象）是可接受的一样。只要 T 能转型为 X，而 someNastyWidget 的类型能够转型为 Y，对 operator!= 的调用就是合法的。

（旁注：此处的分析没有考虑 operator&& 被重载的可能性，这会将上面的表达式的含义从逻辑与转换到某些大概完全不同的东西。）

第一次考虑 implicit interfaces（隐式接口）的时候，大多数人都会头疼，但是他们真的不需要阿司匹林。implicit interfaces（隐式接口）简单地由一套 valid expressions（合法表达式）构成。这些表达式自身看起来可能很复杂，但是它们施加的约束通常是简单易懂的。例如，给出这个条件，

if (w.size() > 10 && w != someNastyWidget) ...

关于 functions size，operator>，operator&& 或 operator!= 上的约束很难说出更多的东西，但是要识别出整个表达式的约束是非常简单的。一个 if 语句的条件部分必须是一个 boolean expression（布尔表达式），所以不管 "w.size() > 10 && w != someNastyWidget" 所产生的精确类型是哪一种，它必须与 bool 相容。这就是 template（模板）doProcessing 施加于它的 type parameter（类型参数）T 之上的 implicit interface（隐式接口）的一部分。doProcessing 必需的 interface（接口）的其余部分是 copy constructor（拷贝构造函数），normalize 和 swap 的调用对于类型 T 的 objects（对象）来说必须是合法的。

implicit interface（隐式接口）对 template（模板）的 parameters（参数）施加的影响正像 explicit interfaces（显式接口）对一个 class（类）的 objects（对象）施加的影响，而且这两者都在编译期间被检查。正像你不能用与它的 class（类）提供的 explicit interface（显式接口）矛盾的方法使用 object（对象）（代码无法编译）一样，除非一个 object（对象）支持 template（模板）所必需的 implicit interface（隐式接口），否则你就不能在一个 template（模板）中试图使用这个 object（对象）（代码还是无法编译）。

Things to Remember

• classes（类）和 templates（模板）都支持 interfaces（接口）和 polymorphism（多态）。

• 对于 classes（类），interfaces（接口）是 explicit（显式）的并以 function signatures（函数识别特征）为中心。polymorphism（多态性）通过 virtual functions（虚拟函数）出现在运行期。

• 对于 template parameters（模板参数），interfaces（接口）是 implicit（隐式）的并基于 valid expressions（合法表达式）。polymorphism（多态性）通过 template instantiation（模板实例化）和 function overloading resolution（函数重载解析）出现在编译期。