C++学习笔记06：虚函数与多态

虚函数

在语法上，给成员函数之前加上virtual关键字

其他成员，如变量，被继承后会占用内存，但是函数的继承的是调用权，子类继承父类的函数，是否需要重新定义？

non-virtual函数：你不希望子类重新定义（覆写）它

virtual（impure）：你希望子类重新定义它，它已有默认定义

pure virtual函数：你希望子类必须重新定义该函数，该函数在父类中没有定义，只是声明，父类不知道该如何定义，在基类中实现纯虚函数的方法是在函数原型后加"=0"

纯虚函数引入的原因：

• 1、为了方便使用多态特性，我们常常需要在基类中定义虚拟函数。
• 2、在很多情况下，基类本身生成对象是不合情理的。例如，动物作为一个基类可以派生出老虎、孔雀等子类，但动物本身生成对象明显不合常理。

将函数定义为纯虚函数（方法：virtual ReturnType Function()= 0;），则编译器要求在派生类中必须予以重写以实现多态性。同时含有纯虚拟函数的类称为抽象类，它不能生成对象。所以，用户不能创建类的实例，只能创建它的派生类的实例。

纯虚函数的意义，让所有的类对象（主要是派生类对象）都可以执行纯虚函数的动作，但类无法为纯虚函数提供一个合理的默认实现。所以类纯虚函数的声明就是在告诉子类的设计者，"你必须提供一个纯虚函数的实现，但我不知道你会怎样实现它"。

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

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

虚函数可以让父类中的函数在一段时间之后被子类实现，比如2、3年后，这种设计模式叫Template Method

举例 ：PPT打开并读取文件

#include <iostream>
using namespace std;

class CDocument
{
public:
    void OnFilerOpen() // cout代替操作
    {
        cout << "dialog..." << endl;
        cout << "check file status..." << endl;
        cout << "open file..." << endl;
        Serialize();
        cout << "close file..." << endl;
        cout << "update all views..." << endl;
    }
    virtual void Serialize() { };
};

// 后来定义的子类 ：
class CMyDoc : public CDocument
{
public:
    virtual void Serialize()
    {
        // 只有应用程序本身才知道如何读取自己的文件，所以要在子类写
        cout << "CMyDoc::Serialize()" << endl;
    }   
};

int main()
{
    CMyDoc myDoc;  // 假设应对File/Open
    myDoc.OnFileOpen();  // 这步既会用到父类的，也会用到子类覆写的virtual函数
}

Inheritance+Compositon关系下的构造和析构

构造是先调用子类还是先调用包含的类的那？这个虽然不重要，但是可以了解下，应该是Component，再Base，再Derived？

析构的时候，则是先析构Derived，然后Base，然后Component

Delegation+Inheritance

如何让一个物体在多个窗口展现，而且物体变化，窗口中展现的内容也一同变化？

设计物体类，还有窗口类，物体类中放指向窗口类的指针，即Delegation，窗口类可以派生出很多子类。

Composite设计模式

以文件系统为例，Primitive类代表基本文件,，也可以看做树形结构中的叶子结点，另外的Composite类表示文件夹，一个容器，可以容纳很多个Primitive，还要可以容纳其它文件夹，可看做树形结构的非叶子结点。那么就有一个容器既可以放Primitive，又可以放Composite，相当于左右都is a（继承）一个东西，也就是目录表Compnent类

Component： 抽象组件，Primitive 和 Composite 都继承于它，这样才使得用户对整体和部分的使用是一致的（用户并不知道哪个是整体，哪个是部分！）。它定义了所有子类公共的缺省行为

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

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

class Composite: public Component
    vector<Component*>c;
public:
    Composite(int val); Component(val) {}
    void add(Component* elem) {
        c.push_back(elem);
    }
...
};

Prototype设计模式

原型模式是一种创建型设计模式，它通过复制一个已经存在的实例来返回新的实例,而不是新建实例。被复制的实例就是我们所称的原型，这个原型是可定制的，在C++中通过拷贝构造函数实现。

#ifndef _PROTOTYPE_H_
#define _PROTOTYPE_H_

/*Prototype模式提供了一个通过已存在对象进行新对象创建的接口（Clone）
  Clone()实现和具体的语言相关，在C++中通过拷贝构造函数实现

作用:
用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。

*/

/*Prototype原型基类，定义Clone接口函数
*/
class Prototype
{
protected:
    Prototype();
public:
    virtual Prototype* Clone() const=0;//定义Clone接口，根据不同的派生类来实例化对象
    virtual ~Prototype();
};

// 派生自Prototype，实现其接口函数
class ConcretePrototype1:public Prototype
{
public:
    ConcretePrototype1();//构造函数
    ~ConcretePrototype1();//析构函数
    ConcretePrototype1(const ConcretePrototype1&);//拷贝构造函数
    virtual Prototype* Clone() const;//实现基类定义的Clone接口，内部调用拷贝构造函数实现复制功能
};

#include "Prototype.h"
#include "iostream"

using namespace std;

// Prototype
Prototype::Prototype()
{
    cout<<"Prototype"<<endl;
}

Prototype::~Prototype()
{
    cout<<"~Prototype"<<endl;
}

// ConcretePrototype1
ConcretePrototype1::ConcretePrototype1()
{
    cout<<"ConcretePrototype1"<<endl;
}

ConcretePrototype1::~ConcretePrototype1()
{
    cout<<"~ConcretePrototype1"<<endl;
}

ConcretePrototype1::ConcretePrototype1(const ConcretePrototype1& cp)
{
    cout<<"ConcretePrototype1 copy"<<endl;
}

Prototype* ConcretePrototype1::Clone() const
{
    return new ConcretePrototype1(*this);
}

#include "Prototype.h"
#include <iostream>
using namespace std;

int main()
{
    /*原型模式作用：用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。
      Prototype模式重在从自身复制自己创建新类，隐藏（不需知道）对象创建的细节
    */

    /*1、用原型实例p1指定创建对象的种类ConcretePrototype1 */
    Prototype* p1 = new ConcretePrototype1();

    /*2、通过拷贝这些原型创建新的对象 */
    Prototype* p2 = p1->Clone();

    cout<< "------------------------" << endl;

    Prototype* p3 = new ConcretePrototype2();
    Prototype* p4 = p3->Clone();

    cout<< "------------------------" << endl;

    delete p1;
    delete p2;
    cout<< "------------------------" << endl;

    delete p3;
    delete p4;

    return 0;
}