面向对象（Object Oriented）

一、三种经典的类与类的关系

（一）Inheritance（继承）

（1）继承关系的结构

（2）继承关系下的构造和析构

• 构造由内而外

Derived 的构造函数先调用Base的default构造函数，然后再调用自己的构造函数

• 析构由外而内

Derived 的析构函数先调用自己，然后再调用Base的析构函数

（二）Composition（复合）

（1）复合关系的结构

Adapter

（2）复合关系下的构造和析构

• 构造由内而外

Container 的构造函数先调用Component的default构造函数，然后再调用自己的构造函数

• 析构由外而内

Container 的析构函数先调用自己，然后再调用Component的析构函数

（三）Delegation（委托）

Delegation（委托）- Composition by reference
Handle/Body(pImpl)

二、继承与虚函数

（一）类中三种类型函数

class Shape
{
public:
	virtual void draw() const = 0;   //纯虚函数，子类必须重新实现
	virtual void error(const std::string& msg); //普通虚函数，有默认实现，子类可以实现子类的版本
	int objectId() const;			//普通函数
};

class Rectangle :public Shape {};
class Ellipse :public Shape {};

• 普通函数：你不希望子类重新定义（override 覆写）它
• 虚函数：你希望子类重新定义（override 覆写）它，且对它有默认定义
• 纯虚函数：你希望子类一定重新定义（override 覆写）它，且对它没有默认定义

（二）一个经典的用法（设计模式-模板方法）

Template Method

// TemplateMethod.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include <iostream>
using namespace std;

class ClassDocument
{
public:
    void OnFileOpen()
    {
        cout << "打开文件" << endl;
        Serialize();
    }
    
    //虚函数
    virtual void Serialize()
    {
        cout << "默认读取文件" << endl;
    }
};

class MyDoc : public ClassDocument
{
public:
    virtual void Serialize()
    {
        cout << "自定义读取文件" << endl;
    }
};

int main()
{
    //子类对象调用父类的函数，通过重写虚函数调用MyDoc 的 Serialize走自己的流程
    MyDoc myDoc;
    myDoc.OnFileOpen();
}

三、继承+复合关系下的构造和析构

// InheritanceAndComposition.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include <iostream>
using namespace std;

class ComponentBase
{
public:
	ComponentBase()
	{
		cout << "ComponentBase 构造函数执行了" << endl;
	}
	~ComponentBase()
	{
		cout << "ComponentBase 析构函数执行了" << endl;
	}
};

class ComponentDerived
{
public:
	ComponentDerived()
	{
		cout << "ComponentDerived 构造函数执行了" << endl;
	}
	~ComponentDerived()
	{
		cout << "ComponentDerived 析构函数执行了" << endl;
	}
};

class Base
{
public:
	Base()
	{
		cout << "Base 构造函数执行了" << endl;
	}
	~Base()
	{
		cout << "Base 析构函数执行了" << endl;
	}
	ComponentBase m_ComBase;
};

class Derived : public Base
{
public:
	Derived()
	{
		cout << "Derived 构造函数执行了" << endl;
	}
	~Derived()
	{
		cout << "Derived 析构函数执行了" << endl;
	}
	ComponentDerived m_ComDerived;
};


int main()
{
	Derived derived;
}

//ComponentBase 构造函数执行了
//Base 构造函数执行了
//ComponentDerived 构造函数执行了
//Derived 构造函数执行了
//Derived 析构函数执行了
//ComponentDerived 析构函数执行了
//Base 析构函数执行了
//ComponentBase 析构函数执行了

四、委托+继承，三种经典的用法

Observer

Composite

Prototype