boolan/C++面向对象高级编程 part3

C++面向对象高级编程 part3

@(boolan C++)[C++]

---

概述

面向对象的三种关系

1. composition 组合
2. delegation 委托
3. inheritance 继承

组合与继承

1. composition 组合 has a

template  {
class queue {
...
protected:
    deque c;

public:
    bool empyt(){ return c.empty()} 
    size_type size() {return c.size();}
    reference front() { return c.front();}
    reference back() {return c.back();}
    void push(const value_type& x) {c.push_back(x);}
    void pop()(c.pop_front();)
}

composition 是has a 的关系。

composition的关系表示法：

1509872201654.png

Adapter模式

Adapter模式： 新的类类型组合包含已有的类型对象，新的类型的功能完全由已有的类型实现，新的类型是已有类型的功能的简化(类似 adapter的功能)。

2.composition 关系下的构造和析构

内存结构

1509872239077.png

构造和析构顺序

构造顺序由内而外，析构顺序由外而内。

1. Container首先调用Component的default构造函数，后调用自己的构造函数。
   图中红色部分为编译器行为。

1509872269289.png

2. Container首先调用自己的析构函数，后调用Component的析构函数。

1509872282635.png

注意⚠️：
构造函数的默认行为，编译器默认在构造函数的初始化列表中调用成员对象的default构造函数。所以在初始化列表中显式初始化成员对象效率要高于在class body内初始化成员函数（避免了重复初始化的动作）。

3. Delegation/委托。 Composition by reference

delegation 即Composition by reference。
通常不讲pointer，仅讲reference。

// file string.hpp
class stringrep;

class string {
public:
....
private:
    stringrep* rep;  // pimpl
};

// string.cpp
#include "string.hpp" 

namespace {
class stringrep {
friend class string;
int count;
char* rep;
};
}

Delegation的关系表示法

1509872298319.png

delegation 虽然能够访问某对象，但其成员对象是指向某对象的指针。指针成员指向的对象的创建和析构都不一定由我控制。

delegation中指针成员的生命周期和其所指对象的生命周期不一致。compositon中生命周期一致。

pImpl模式/ （Handle/Body）

p for pointer。

1. pImpl将实现的声明分离，提供了灵活性。这种灵活性来源于delegation中指针成员生命周期与其指向对象的不一致。

string的引用计数和copy on write

1509872311553.png

引用计数：string中采用引用计数的方式在内容相同对象间共享数据。
copy on write：共享数据的对象间如果有人要改写自己的数据，则copy共享的数据到新分配的内存（目的是不破坏共享数据）。

copy on write 应用：string 对象间拷贝不会创建新的内存，因为有引用计数机制，仅在copy之后要改写对象才会创建新内存（copy on write）。

4. Inheritance/ 继承. Is - a

继承,委托,组合都是面向对象。

struct _List_node_base{
    _List_node_base* _M_next;
    _List_node_base* _M_prev;
}

template
struct _List_node :public _List_node_base
{
    _Tp _M_data;
}

继承的表示方法

1509872324297.png

T表示 Template class

public继承

1. public继承 is-a关系。
2. 继承的价值在于与虚函数搭配。

派生类成员对基类成员的访问

1. 基类的private成员，只有基类和基类的友元可以访问。
2. 基类的public，protected成员，派生列表中使用的访问标号决定该成员在派生类中的访问级别

派生列表中的访问标号

访问标号仅影响基类的public，potected成员在派生类中的访问级别。

1. public继承：基类成员在派生类中的访问级别保持不变。
2. prtoceted继承： 基类的public，protected成员在派生类中为protected成员。
3. private继承：基类的public，protected成员在派生类中为private成员。

::无论以何种方式继承，派生类对基类成员的访问权限一致，继承类型仅影响派生类用户对基类成员的访问级别。::

Inheritance关系下的构造和析构

内存模型

1509872337816.png

构造和析构顺序

构造由内而外， 析构由外而内。类似于compositon的顺序。

1. Derived 的构造函数，先调用base的default构造函数，后调用自己的构造函数。base的default构造函数在derived的构造初始化列表中被默认调用
   Derived::Dervied(…): Base() {};

2. Derived的析构函数，先执行自己的析构函数，后调用base的析构函数。
   Derived::~Derived(…) {… ~Base()};

base的析构函数必须是virtual

如果多态基类的析构函数是non-virtual的，会造成“局部对象销毁”，仅销毁了基类的对象。

---

虚函数与多态

1. derived class 继承了 base class 的哪些东西？

1. 内存数据
2. 函数的调用权

derived class 继承了base class 的函数调用权，所以 derived class 可以调用base class的函数。

2. Inheritance with virtual function

注意⚠️：
virutal函数的设计取决于derived class 是否想要重新定义（override/ 覆盖）base class的已有定义。这里要区分重载(overload)和覆盖(override)。

virtual function

class Shape {
public:
    virutal void draw() const = 0;  // pure virtual
    virtual void error(const std::string& msg);  // impure virtual
    int objectID() const;  // non-virtual

1. non-virtual ： 不希望derived class 重新定义（override / 覆盖）它（base class function member）。
2. virtual： 希望derived class重新定义它，且它已有默认定义。
3. pure virtual：希望derived class一定要重新定义它，且它没有默认定义。

理解‍♂️：

1. 虚函数的声明在base class中指定， 控制derived class对接口的继承能力。
2. 虚函数使derived class继承了base class 接口的同时，让dervied class具有进化该接口行为的能力。

注意⚠️：

1. 不能创建具有纯虚函数类型的对象。
2. 继承于纯虚类的dervied class 中具有纯虚类对象。

template method

class CDocument {
public:
    virutal Serialize(){};
    OnFileOpen() {  // template method
        ...
        Serialize();
    }
}

class CMyDocument : public CDocument {
    virtual Serialize() {....}
}

....

int main () {
    CMyDocument doc;
    doc.OnFileOpen();
}

OnFileOpen就是template method；

template method：

template method的做法将已实现base类型的部分功能，延缓实现，将其交由derived class 实现。
将Application Framework框架和Application实现分离。

理解

1. template method即 ，在其实现中调用base class virtual function的base class non-virtual function 。
2. 好处：
   derived class 可以复用base class 中non-virtual function实现中通用的框架/流程/接口，但针对不同derived class object的调用 non-virtual function 的行为略有差异(差异在non-virtual function中调用virtual function)。

virtual function调用过程

注意下图中this指针的作用。

1509872370689.png

3. Inheritance + Composition 关系下的构造和析构

内存模型/UML关系

1509872400702.png

构造由内而外，析构由外而内

1. Derived 的构造函数首先调用base的default 构造函数，
   然后调用Component的default构造函数，
   最后调用自己的构造函数。
   Derived::Derived(...) : Base(),Component() {...};

2. Derived 首先调用自己的析构函数，
   然后调用Component的析构函数，
   最后调用base的析构函数
   Derived::~Derived(){... ~Componet(),~Base()};

---

委托+继承设计

设计思想：用composition(组合)/delegation(委托)/inheritance(继承)三个工具，去设计解决现实问题的方法。

理解 1：委托应用于设计的灵活性在于对象创建的灵活性，delegation class a对象可以通过指针的方式间接拥有某对象，该被拥有的对象创建方式可以很动态。

理解 2: 委托+继承强化了委托的应用，鉴于base指针可以指向derived class对象。

0. Obeserver

class Subject {
    int m_value;
    vector m_views;
public:
    void attach(Observer* obs) {
        m_views.push_back(obs);
    }
    void set_value(int value) {
        m_value = value;
        notify();
    }
    void notify() {
        for(int i = 0; i < m_views.size(); ++i)
            m_views[i]->update(this, m_value);
    }
}


class Observer {
public:
    virtual void update(Subject* sub, int value) = 0;
}

UML关系图

1509872417801.png

1. 类似文件系统的问题解决

文件系统问题？

如何设计目录的数据结构？目录中既有文件类型，又包含目录类型。

用composite设计模式/ delegation + inheritance 解决问题

1509872430936.png

1. composite解决的问题？用一种结构能够同时保存多种不同类型的数据。
2. base类指针数组，解决上述问题，注意必须是指针数组，因为指针的大小固定。

example code

class Primitive : public Component {
public:
    Primitive(int val): Component(val){}
};

class Component {
    int value;
public:
    Component(int val) {value = val;}
    virutal void add(Component*) {}
};

class Composite: public Component {
    vectorc;
public:
    Composite(int val):Component(val) {}

    void add(Componet* elem) {
        c.push_back(elem);
    }
}

2. Prototype

UML

1509872444226.png

1. 静态成员的表示方法，在成员的名称下面添加下划线
2. 数据成员的表示方法，成员名称在前，类型在后。

Prototype要解决的问题

1. 在base类种如何创建未来才会设计的类型对象。在不知道对象类型的前提下创建对象。
2. 主要发生在框架设计中，框架设计者不知道未来使用者的类型。

注意⚠️：

1. prototype中，是在dervied类自己创建对象，不是使用者创建dervied对象，所以dervied类中包含一个static derived类对象。
2. derived类自己创建对象并注册到base类中。
3. prototype中，base类中创建derived类对象，而不是base类/dervied类对象中的base对象

---