9，多态

一、名词解释

---

　　1，多态

　　　 1）静态多态：a) 函数多态：函数重载，运算符重载

　　　　　　　　　　b) 模板多态：函数模板，类模板

　　　 2）动态多态：虚函数（切记：只有通过指针或引用才能实现动态多态性。"对象.虚函数“ 和 ”类::虚函数“ 这两种形式不能实现多态）

　　2，静态类型与动态类型

　　　 1） 静态类型：声明对象时，对象被赋予的类型，编译时期确定。

　　　 2） 动态类型：指针或引用所指对象的类型。常常是，基类指针指向派生类对象，那么这个指针(或引用)的静态类型是基类指针或引用，其动态类型就是派生类指针或引用。

　　3，静态绑定与动态绑定

　　　1） 静态绑定：亦或静态联编。在编译程序时就根据调用函数提供的信息，把它所对应的具体函数确定下来（编译时期，把调用函数名与具体函数绑定在一起。）

　　　2） 动态绑定：亦或动态联编。在编译程序时还不能确定函数调用所对应的具体函数，只有在程序运行过程中才能够确定函数调用所对应的具体函数。

　　　巧计：动态绑定只发生在继承类的虚函数上（且这个虚函数无缺省参数），其它一概是静态绑定。

二、实例解析

---

　　我们看下面这一个示例。

#include <iostream>
using  namespace std;
class A
{
public:
    virtual void func(int val = 1) {
        cout<< "A->" << val << endl;
    }
    virtual void test() {
        func();
    }

    virtual void func2() {
        cout << "Base A" << endl;
    }
};
class B : public A
{
public:
    void func(int val = 0) {
        cout<<"B->"<<val <<endl;
    }
    void func2() {
        cout << "Base B" << endl;
    }
};
int main(int argc ,char* argv[])
{
    cout << "Virtual function with default parameters." << endl;
    B*p = new B;    //p的静态类型和动态类型都是 B*
    p->test();
    p->func2();

    cout << endl << "reference work with virtual function." << endl;
    B objectB;
    A &objectA = objectB;   //objectA的静态类型是 A&, 动态类型是 B&
    objectA.func();
    objectA.func2();

    cout << endl << "object work with virtual functions." << endl;
    A objectA2;
    objectA2.func();
    objectA2.func2();
    return 0;
}

　　1，静态类型，动态类型已在程序中注释

　　2，程序输出

　　

　　1）第一输出

　　　　这一输出是测试带有缺省参数的虚函数。我们看到，基类虚函数的缺省参数没有被修改。（这一情况，总说纷纭，有的把他归于动态绑定，有的归于静态绑定）。所以，尽量不要定义继承而来的缺省参数。

　　2）第二输出

　　　　用基类引用调用派生类虚函数，实现多态。

　　3）第三输出

　　　　基类对象调用自家成员函数，忽略virtual关键字。

三、构造函数，析构函数不要调用虚函数

---

　　我们先看下示例代码。

#include "stdio.h"
class Base
{
public:
    Base()
    {
        Init();
    }
    virtual void Init()
    {
        printf("Base Init
");
    }
    void func()
    {
        printf("Base func
");
    }
};
class Derived: public Base
{
public:
    virtual void Init()
    {
        printf("Derived Init
");
    }
    void func()
    {
        printf("Derived func
");
    }
};
 
int main()
{
    Derived d;
    ((Base *)&d)->func();
     
    return 0;
}

　　程序输出为：

Base Init
Base func

　　我们从输出中可以看到，此时的虚函数并没有发挥它动态绑定的效果。这是因为，在基类构造的时候，虚函数是非虚，不会走到派生类中，既是采用的静态绑定。显然的是：当我们构造一个子类的对象时，先调用基类的构造函数，构造子类中基类部分，子类还没有构造，还没有初始化，如果在基类的构造中调用虚函数，如果可以的话就是调用一个还没有被初始化的对象，那是很危险的，所以C++中是不可以在构造父类对象部分的时候调用子类的虚函数实现。但是不是说你不可以那么写程序，你这么写，编译器也不会报错。只是你如果这么写的话编译器不会给你调用子类的实现，而是还是调用基类的实现。

　　在析构函数中也不要调用虚函数。在析构的时候会首先调用子类的析构函数，析构掉对象中的子类部分，然后在调用基类的析构函数析构基类部分，如果在基类的析构函数里面调用虚函数，会导致其调用已经析构了的子类对象里面的函数，这是非常危险的。