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

字数 2134阅读 76

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

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


概述

面向对象的三种关系

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

组合与继承

1. composition 组合 has a

template <class T> {
class queue {
...
protected:
    deque<T> 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
  1. 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<typename _Tp>
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<Observer*> 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 {
    vector<Component*>c;
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对象

推荐阅读更多精彩内容