C++箴言：通过composition模拟“has-a”

　　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。
　　
　　《C++箴言：确保公开继续模拟“is-a”》解释了 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> { ... };
　　在这里，看起来每件事情都很好。但实际上有一个很大的错误。就像《C++箴言：确保公开继续模拟“is-a”》中的解释，假如 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 =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（内联化）的决心之前，你可能需要回顾一下《C++箴言：理解inline化的介入和排除》中的讨论。
　　
　　一个有说服力的观点是，根据《C++箴言：使接口易于正确使用难错误使用》文中的关于将 interfaces（接口）设计得易于正确使用，而难以错误使用的论述，假如要遵循 STL container（容器）的惯例，Set 的 interface（接口）应该更多，但是在这里遵循那些惯例就需要在 Set 中填充大量 stuff（材料），这将使得它和 list 之间的关系变得暧昧不清。因为这个关系是本文的重点，我们用教学的清楚性替换了 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（是根据……实现的）。