面向对象编程和设计 (Boolan)

Object Oriented Programming and Object Oriented Design(面向对象编程和设计)

本章内容：
1 组合与继承
2 虚函数与多态
3 委托相关设计

---

1 组合与继承

• 在该节中包含了三种关系：
  (1). Composition(复合)
  (2). Delegation(委托)
  (3). Inheritance(继承)

(1) Composition(复合)

• 复合表示has-a关系，例如queue包含deque，代码如下所示：

has-a关系图

• 复合关系下的构造和析构，下图中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 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;iupdate(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 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) {}
    };