Object Oriented Programming and Object Oriented Design(面向对象编程和设计)
本章内容：
1 组合与继承
2 虚函数与多态
3 委托相关设计
1 组合与继承
- 在该节中包含了三种关系：
(1). Composition(复合)
(2). Delegation(委托)
(3). Inheritance(继承)
(1) Composition(复合)
- 复合表示
has-a关系，例如queue包含deque，代码如下所示：
-
复合关系下的构造和析构，下图中
Container包含Component，UML图和对象结构图如下所示：
UML和对象结构图 构造由内而外：
-
Container的构造函数首先调用Component的default构造函数，然后再执行自己的构造函数，如下所示：Container::Container(...) : Component() {...} 其中
Component()是编译器默认添加上去的。析构由外而内：
-
Container的析构函数首先执行自己的析构函数，然后再调用Component的析构函数，如下所示：Container::~Container(...) {... ~Component(); } 其中
~Component()是编译器默认添加上去的。
(2) Delegation(委托)
-
委托可以用Composition by reference表示，其中Composition by reference在这表示指针的意思，UML图如下所示：
Delegation(委托) -
经典的pImpl(point to implement)或Handle/Body模式，如下代码所示：
class StringRep; class String { public: String(); String(const char* s); String(const String& s); String& operator=(const String& s); ~String(); ...... private: StringRep* rep; // pImpl }; class StringRep { public: friend class String; StringRep(const char* s); ~StringRep(); private: int count; char* rep; }; String::String() { ... } ...... 这个pImpl俗称“编译防火墙”，其可以用一个指针指向一个类，
StringRep类实现了具体的方法功能，String类只调用StringRep类的指针来实现其定义的接口，如此一来对外接口可以保持不变，而具体的实现部分可以根据实际要求来用不同的方式实现，从而达到了接口和实现隔离的效果。
(3) Inheritance(继承)
-
继承表示
is-a关系，如下图表示：
is-a关系图 -
继承关系下的构造和析构：
UML和对象结构图 构造由内而外：
-
Derived的构造函数首先调用Base的defaule构造函数，然后再执行自己的构造函数，如下代码所示：Derived::Derived(...) : Base() { ... } 其中
Base()是编译器默认添加上去的。析构由外而内：
-
Derived的析构函数首先执行自己的构造函数，然后再调用Base的析构函数，如下代码所示：Derived::Derived(...) { ... ~Base() } 其中
~Base()是编译器默认添加上去的。
注意:base class的destructor必须是virual的，否则会造成内存泄漏或其他没有定义的行为。
2 虚函数与多态
Inheritance(继承) with virtual functions(虚函数)
(1).non-virtual函数：你不希望derived class重新定义(override，覆写)它。
(2).virtual函数：你希望derived class重新定义(override，覆写)它，且你对它已有默认定义。
(3).pure virtual函数：你希望derived class一定要重新定义(override，覆写)它，你对它没有默认定义。-
三种
functions的代码表示方式如下图：
virtual functions虚函数 -
Inheritance+Composition关系下的构造和析构
(1) Derived has a Component & Derived is a Base，UML图如下所示：
UML图 构造由内而外：
Derived的构造函数首先调用Base的default构造函数，然后调用Component的构造函数，最后执行自己的构造函数。析构由外而内：
-
Derived的析构函数首先执行自己的构造函数，然后调用Component的析构函数，最后调用Base的析构函数。(2) Derived is a Base & Base has a Component，UML图如下所示：
UML图 构造由内而外：
Derived的构造函数首先调用Component的构造函数，然后调用Base的default构造函数，最后执行自己的构造函数。析构由外而内：
Derived的析构函数首先执行自己的构造函数，然后调用Base的析构函数，最后调用Component的析构函数。
3 委托相关设计
Delegation(委托)+Inheritance(继承)
-
委托+继承的用法之
Observe(观察者)模式，UML图如下所示：
观察者模式UML图 -
具体代码示例如下：
class Observer { public: virtual void update(int value) = 0; }; class Subject { private: int m_value; vector<Observer*> m_views; public: void attach(Observer* obs) { m_views.push_back(obs); } void set_val(int value) { m_value = value; notify(); } void notify() { for (int i=0;i<m_views.size();i++) { m_views[i]->update(m_value); } } }; // 继承观察者类 class Observer1 : public Observer { private: int m_div; public: Observer1(Subject* model, int div) { model->attach(this); m_div = div; } void update(int v) { ... } }; class Observer2 : public Observer { private: int m_mod; public: Observer2(Subject* model, int mod) { model->attach(this); m_mod= mod; } void update(int v) { ... } }; // 使用详解 int main(void) { Subject subj; Observer1 o1(&subj, 4); Observer1 o2(&subj, 3); Observer2 o3(&subj, 3); subj.o1(14); } -
(2) 委托+继承的用法之
Composite(组合)模式，UML图如下所示：
组合模式UML图 -
具体代码示例如下：
class Component { private: int value; public: Component(int val) { value = val; } virtual void add(Component*) {} }; class Composite : public Component { private: vector<Component*> c; public: Composite(int val) : Component(val) {} void add(Component* elem) { c.push_back(elem); } ...... }; class Primitive : public Component { public: Primitive(int val) : Component(val) {} };
