[Boolan] C++ 面向对象高级编程 第三周学习笔记

1.Inheritance(继承)

继承表示一种 "is-a"的关系，有基类（base class） 和 派生类(derived call)。继承有单继承和多重继承，同时继承的访问权限有public,private,protected (默认的是 private).

class base
{
	int num;//默认访问权限是 private:
public:
	base(int n):num(n){}
	virtual ~base(){}
};
class base2
{
	int num2;//默认访问权限是 private:
public:
	base2(int n) :num2(n) {}
	virtual ~base2() {}

};
class MyClass :public base{};//公有继承
class MyClass :private base {};//私有继承
class MyClass :protected base {};//保护继承
class MyClass :public base,base2 {};//公有多层继承

构造函数

    构造步骤 ： 由内而已进行的，意思先 构造基类 再构造派生类。

析构函数

    析构步骤：由外而内的，先派生类析构，然后基类析构。

    注意:纯虚基类的析构函数必须是虚析构函数，否则无法调用派生类的析构函数

class base
{
	int num;//默认访问权限是 private:
public:
	base(int n):num(n){}
	virtual ~base(){}--纯虚析构
};

继承中的虚函数

1.non-virtual 函数：不希望派生类重新（override）;

2.virtual函数：派生类可以重写它，如果不重写，可以使用基类默认的；

3.pure-virtual函数：纯虚函数，派生类必须要重写它，如果全部是纯虚函数的类该类为抽象类，

class base
{
	int num;//默认访问权限是 private:
public:
	base(int n):num(n){}
	virtual ~base(){}
	virtual int getMax()const = 0;//纯虚函数声明
	virtual void setNum(int num) = 0;//纯虚函数声明
};

Composition(复合)

复合表示 “has-a”的关系。类包含其他类

class base2
{
	int num2;//默认访问权限是 private:
public:
	base2(int n=0) :num2(n) {}
	virtual ~base2() {}

};
class MyClass
{
public:
	base2 base1;
	MyClass(){}
};

复合的构造函数 由内而外。

复合的析构函数 由外而内。

Delegation(委托)

委托：一种以指针方式的复合。一个类包含另外一个类的指针。

class base2
{
	int num2;//默认访问权限是 private:
public:
	base2(int n=0) :num2(n) {}
	virtual ~base2() {}

};
class MyClass
{
public:
	base2 *base1;//类指针
	MyClass(){}
};

面向对象的设计模式

Template Method

模板模式：预先定义好操作框架，预留一些步骤的实现给子类去实现。

继承中的虚函数完成这些功能。

CDocum::OnOpen()
{
...
virtual Serialize();
...
}

class CDoc:public CDocum
{
    virtual Serialize() {...}
}

Observer

观察者模式，一种一对多的依赖关系，其中一个改变时，所有其他依赖的对象都能自动的被通知和更新。

class Subject
{
    int m_value;
    vector<Observer*> 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; i < m_views.size(); ++i)
        {
            m_views[i]->update(this, m_value);
        }
    }

};

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

class Observer1: public Observer
{
    void update(int v)
    {
    ...
    }
};
class Observer2: public Observer
{
    void update(int v)
    {
    ...
    }
};

Composite

Composite的典型例子就是文件系统。文件系统由目录和文件组成。每个目录都可以装内容。目录的内容可以是文件，也可以是目录。按照这种方式，计算机的文件系统就是以递归结构来组织的。如果你想要描述这样的数据结构，那么你可以使用组合模式Composite。
C++ 中可以通过 Delegation＋Inheritance 实现

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

class Composite:public Component
{
    vector<Component*> c;
public:
    Composite(int val):Component(val) {}

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

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