多态

多态是指同样的方法调用而执行不同的操作，运行不同的代码。
多态的概念基于对象引用的动态覆盖（重写）。
只有基类成员是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;}