C++面向对象高级编程 part3
@(boolan C++)[C++]
概述
面向对象的三种关系
- composition 组合
- delegation 委托
- 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的关系表示法：
Adapter模式
Adapter模式： 新的类类型组合包含已有的类型对象，新的类型的功能完全由已有的类型实现，新的类型是已有类型的功能的简化(类似 adapter的功能)。
2.composition 关系下的构造和析构
内存结构
构造和析构顺序
构造顺序由内而外，析构顺序由外而内。
- Container首先调用Component的default构造函数，后调用自己的构造函数。
图中红色部分为编译器行为。
- Container首先调用自己的析构函数，后调用Component的析构函数。
注意⚠️：
构造函数的默认行为，编译器默认在构造函数的初始化列表中调用成员对象的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的关系表示法
delegation 虽然能够访问某对象，但其成员对象是指向某对象的指针。指针成员指向的对象的创建和析构都不一定由我控制。
delegation中指针成员的生命周期和其所指对象的生命周期不一致。compositon中生命周期一致。
pImpl模式/ （Handle/Body）
p for pointer。
- pImpl将实现的声明分离，提供了灵活性。这种灵活性来源于delegation中指针成员生命周期与其指向对象的不一致。
string的引用计数和copy on write
引用计数：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;
}
继承的表示方法
T表示 Template class
public继承
- public继承 is-a关系。
- 继承的价值在于与虚函数搭配。
派生类成员对基类成员的访问
- 基类的private成员，只有基类和基类的友元可以访问。
- 基类的public，protected成员，派生列表中使用的访问标号决定该成员在派生类中的访问级别
派生列表中的访问标号
访问标号仅影响基类的public，potected成员在派生类中的访问级别。
- public继承：基类成员在派生类中的访问级别保持不变。
- prtoceted继承： 基类的public，protected成员在派生类中为protected成员。
- private继承：基类的public，protected成员在派生类中为private成员。
::无论以何种方式继承，派生类对基类成员的访问权限一致，继承类型仅影响派生类用户对基类成员的访问级别。::
Inheritance关系下的构造和析构
内存模型
构造和析构顺序
构造由内而外， 析构由外而内。类似于compositon的顺序。
Derived 的构造函数，先调用base的default构造函数，后调用自己的构造函数。base的default构造函数在derived的构造初始化列表中被默认调用
Derived::Dervied(…): Base() {};Derived的析构函数，先执行自己的析构函数，后调用base的析构函数。
Derived::~Derived(…) {… ~Base()};
base的析构函数必须是virtual
如果多态基类的析构函数是non-virtual的，会造成“局部对象销毁”，仅销毁了基类的对象。
虚函数与多态
1. derived class 继承了 base class 的哪些东西？
- 内存数据
- 函数的调用权
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
- non-virtual ： 不希望derived class 重新定义（override / 覆盖）它（base class function member）。
- virtual： 希望derived class重新定义它，且它已有默认定义。
- pure virtual：希望derived class一定要重新定义它，且它没有默认定义。
理解♂️：
- 虚函数的声明在base class中指定， 控制derived class对接口的继承能力。
- 虚函数使derived class继承了base class 接口的同时，让dervied class具有进化该接口行为的能力。
注意⚠️：
- 不能创建具有纯虚函数类型的对象。
- 继承于纯虚类的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实现分离。
理解
- template method即 ，在其实现中调用base class virtual function的base class non-virtual function 。
- 好处：
derived class 可以复用base class 中non-virtual function实现中通用的框架/流程/接口，但针对不同derived class object的调用 non-virtual function 的行为略有差异(差异在non-virtual function中调用virtual function)。
virtual function调用过程
注意下图中this指针的作用。
3. Inheritance + Composition 关系下的构造和析构
内存模型/UML关系
构造由内而外，析构由外而内
Derived 的构造函数首先调用base的default 构造函数，
然后调用Component的default构造函数，
最后调用自己的构造函数。
Derived::Derived(...) : Base(),Component() {...};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关系图
1. 类似文件系统的问题解决
文件系统问题？
如何设计目录的数据结构？目录中既有文件类型，又包含目录类型。
用composite设计模式/ delegation + inheritance 解决问题
- composite解决的问题？用一种结构能够同时保存多种不同类型的数据。
- 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
- 静态成员的表示方法，在成员的名称下面添加下划线
- 数据成员的表示方法，成员名称在前，类型在后。
Prototype要解决的问题
- 在base类种如何创建未来才会设计的类型对象。在不知道对象类型的前提下创建对象。
- 主要发生在框架设计中，框架设计者不知道未来使用者的类型。
注意⚠️：
- prototype中，是在dervied类自己创建对象，不是使用者创建dervied对象，所以dervied类中包含一个static derived类对象。
- derived类自己创建对象并注册到base类中。
- prototype中，base类中创建derived类对象，而不是base类/dervied类对象中的base对象