多态

多态是指同样的方法调用而执行不同的操作，运行不同的代码。
多态的概念基于对象引用的动态覆盖（重写）。
只有基类成员是virtual才会是覆盖（重写），注意区分重载和隐藏
重载是同一区域内，函数名相同，参数列表不同，与返回值和virtual均无关系。
隐藏是第一种：父类与子类中，成员函数名相同，参数列表不同，与返回值和virtual均无关系，子类的隐藏父类的。
第二种：父类与子类中，成员函数名相同，参数列表相同，与返回值无关，父类不是virtual，子类的隐藏父类的。

虚函数与抽象类

//抽象类
class A
{
public:
    //虚函数
    virtual ~A();
    virtual void func();
};

含有虚函数的类就是抽象类

纯虚函数与接口类

//接口类
class A
{
public:
    //纯虚函数
    virtual ~A() = 0;
    virtual void func() = 0;
};

纯虚函数就是把 虚函数=0
接口类就是含有纯虚函数的类，含有纯虚函数的类不能生成具体实现的对象。

必须为多态父类声明虚析构函数
例1.

class A
{
public:
    A(){
        cout << "Constructing A" << endl;
    }
    ~A(){
        cout << "Destructing A" << endl;
    }
};

class B : public A
{
public:
    B(){
        cout << "Constructing B" << endl;
    }
    ~B(){
        cout << "Destructing B" << endl;
    }
};

int main()
{
    A* a = new B;
    delete a;
    a = NULL;

    return 0;
}

输出：
Constructing A
Constructing B
Destructing A

不会调用B的析构函数，有时候会造成内存的泄露。

例2.

class A
{
public:
    A(){
        cout << "Constructing A" << endl;
    }
    virtual ~A(){
        cout << "Destructing A" << endl;
    }
};

class B : public A
{
public:
    B(){
        cout << "Constructing B" << endl;
    }
    ~B(){
        cout << "Destructing B" << endl;
    }
};

int main()
{
    A* a = new B;
    delete a;
    a = NULL;

    return 0;
}

输出：
Constructing A
Constructing B
Destructing B
Destructing A

例3.

class A
{
public:
    void func(){
        cout << "A" << endl;
    }

    void func(int a){
        cout << "A" << endl;
    }
};

class B : public A
{
public:
    void func(){
        cout << "B" << endl;
    }

    void func(int* b){
        cout << "B" << endl;
    }
};

int main()
{
    int t = 1;

    A* a = new B;
    //A中的成员函数隐藏的B中的成员函数（？）
    a->func();  //结果为A
    a->func(1); //结果为A
    a->func(&t);//error
    //B中的成员函数隐藏了A中的成员函数
    B* b = new B;
    b->func();  //结果为B
    b->func(&t);//结果为B
    b->func(1); //error

    return 0;
}

例4.

class A
{
public:
    virtual void func(){
        cout << "A" << endl;
    }

    virtual void func(int a){
        cout << "A" << endl;
    }
};

class B : public A
{
public:
    void func(){
        cout << "B" << endl;
    }

    void func(int* b){
        cout << "B" << endl;
    }
};

int main()
{
    A* a = new B;
    a->func();  //结果为B A中virtual函数被B中的函数覆盖（重写）
    a->func(1); //结果为A A中的成员函数隐藏的B中的成员函数（？）

    return 0;
}