Item 38: 通过 composition(复合)模拟 "has-a"(有一个)或 "is-implemented-in-terms-of"(是根据……实现的)

作者:Scott Meyers

译者:fatalerror99 (iTePub's Nirvana)

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

composition(复合)是在 objects of one type(一个类型的对象)包含 objects of another type(另一个类型的对象)时,types(类型)之间的关系。例如:

class Address { ... };             // where someone lives

class PhoneNumber { ... };

class Person {
public:
  ...

private:
  std::string name;               // composed object
  Address address;                // ditto
  PhoneNumber voiceNumber;        // ditto
  PhoneNumber faxNumber;          // ditto
};

此例之中,Person objects(对象)由 string,Address,和 PhoneNumber objects(对象)组成。在程序员中,术语 composition(复合)有很多同义词。它也可以称为 layering,containment,aggregation,和 embedding。

Item 32 解释了 public inheritance(公有继承)意味着 "is-a"(是一个)。composition(复合)也有一个含意。实际上,他有两个含意。composition(复合)既意味着 "has-a"(有一个),又意味着 "is-implemented-in-terms-of"(是根据……实现的)。这是因为你要在你的软件中处理两个不同的 domains(领域)。你程序中的一些 objects(对象)对应你所模拟的世界里的东西,例如,people(人),vehicles(交通工具),video frames(视频画面)等等。这样的 objects(对象)是 application domain(应用领域)的部分。另外的 objects(对象)纯粹是 implementation artifacts(实现的产物),例如,buffers(缓冲区),mutexes(互斥体),search trees(搜索树)等等。这些各类 objects(对象)定义应你的软件的 implementation domain(实现领域)。当 composition(复合)发生在 application domain(应用领域)的 objects(对象)之间,它表达一个 has-a(有一个)的关系,当它发生在 implementation domain(实现领域),它表达一个 is-implemented-in-terms-of(是根据……实现的)的关系

上面的 Person class(类)示范了 has-a(有一个)的关系。一个 Person object(对象)has a(有一个)名字,一个地址,以及语音和传真电话号码。你不能说一个人 is a(是一个)名字或一个人 is an(是一个)地址。你可以说一个人 has a(有一个)名字和 has an(有一个)地址。大多数人对此区别不难理解,所以混淆 is-a(是一个)和 has-a(有一个)之间的角色的情况非常少见。

is-a(是一个)和 is-implemented-in-terms-of(是根据……实现的)之间的区别稍微有些棘手。例如,假设你需要一个类的模板来表现相当小的 objects(对象)的 sets,也就是说,排除重复的集合。因为 reuse(复用)是一件受人欢迎的事情,你的第一个直觉就是使用标准库中的 set template(模板)。当你能使用已经被写好的东西时,为什么还要写一个新的 template(模板)呢?

不幸的是,set 的典型实现导致每个元素三个指针的开销。这是因为 sets 通常被作为 balanced search trees(平衡搜索树)来实现,这允许它们保证 logarithmic-time(对数时间)的 lookups(查找),insertions(插入)和 erasures(删除)。当速度比空间更重要的时候,这是一个合理的设计,但是当空间比速度更重要时,对你的程序来说就有问题了。因而,对你来说,标准库的 set 为你提供了不合理的交易。看起来你终究还是要写你自己的 template(模板)。

reuse(复用)依然是一件受人欢迎的事情。作为 data structure(数据结构)的专家,你知道实现 sets 的诸多选择,其中一种是使用 linked lists(线性链表)。你也知道标准的 C++ 库中有一个 list template(模板),所以你决定(复)用它。

具体地说,你决定让你的新的 Set template(模板)从 list 继承。也就是说,Set<T> 将从 list<T> 继承。毕竟,在你的实现中,一个 Set object(对象)实际上就是一个 list object(对象)。于是,你就像这样声明你的 Set template(模板):

template<typename T>                       // the wrong way to use list for Set
class Set: public std::list<T> { ... };

在这里,看起来每件事情都很好。但实际上有一个很大的错误。就像 Item 32 中的解释,如果 D is-a(是一个)B,对于 B 成立的每一件事情对 D 也成立。然而,一个 list object(对象)可以包含重复,所以如果值 3051 被插入一个 list<int> 两次,那个 list 将包含 3051 的两个拷贝。与此对照,一个 Set 不可以包含重复,所以如果值 3051 被插入一个 Set<int> 两次,那个 set 只包含该值的一个拷贝。因此一个 Set is-a(是一个)list 是不正确的,因为对 list objects(对象)成立的某些事情对 Set objects(对象)不成立。

因为这两个 classes(类)之间的关系不是 is-a(是一个),public inheritance(公有继承)不是模拟这个关系的正确方法。正确的方法是认识到一个 Set object(对象)可以 be implemented in terms of a list object(是根据一个 list 对象实现的):

template<class T>                   // the right way to use list for Set
class Set {
public:
  bool member(const T& item) const;

  void insert(const T& item);
  void remove(const T& item);

  std::size_t size() const;

private:
  std::list<T> rep;                 // representation for Set data
};

Set 的 member functions(成员函数)可以极大程度地依赖 list 和标准库的其它部分已经提供的机能,所以只要你熟悉了用 STL 编程的基本方法,实现就非常简单了:

template<typename T>
bool Set<T>::member(const T& item) const
{
  return std::find(rep.begin(), rep.end(), item) != rep.end();
}

template<typename T>
void Set<T>::insert(const T& item)
{
  if (!member(item)) rep.push_back(item);
}

template<typename T>
void Set<T>::remove(const T& item)
{
  typename std::list<T>::iterator it =               // see Item 42 for info on
    std::find(rep.begin(), rep.end(), item);         // "typename" here
  if (it != rep.end()) rep.erase(it);
}

template<typename T>
std::size_t Set<T>::size() const
{
  return rep.size();
}

这些函数足够简单,使它们成为 inlining(内联化)的合理候选者,可是我知道在坚定 inlining(内联化)的决心之前,你可能需要回顾一下 Item 30 中的讨论。

一个有说服力的观点是,根据 Item 18 的关于将 interfaces(接口)设计得易于正确使用,而难以错误使用的论述,如果要遵循 STL container(容器)的惯例,Set 的 interface(接口)应该更多,但是在这里遵循那些惯例就需要在 Set 中填充大量 stuff(材料),这将使得它和 list 之间的关系变得暧昧不清。因为这个关系是本 Item 的重点,我们用教学的清晰性替换了 STL 的兼容性。除此之外,Set 的 interface(接口)的幼稚不应该遮掩关于 Set 的无可争辩的正确:它和 list 之间的关系。这个关系不是 is-a(是一个)(虽然最初看上去可能很像),而是 is-implemented-in-terms-of(是根据……实现的)。

Things to Remember

  • composition(复合)与 public inheritance(公有继承)的意义完全不同。

  • 在 application domain(应用领域)中,composition(复合)意味着 has-a(有一个)。在 implementation domain(实现领域)中意味着 is-implemented-in-terms-of(是根据……实现的)。

powered by Gitbook 该教程制作时间: 2015-12-29 12:06:17