1、静态类型和动态类型

静态类型：对象定义时的类型，编译期间就确定好的。定义的时候是什么就是什么。

动态类型：对象目前所指向的类型，运行时才确定的类型。一般只有指针和引用才有动态类型。

比如下面的代码：

class Base {

};
class Derive : public Base {

};
class Derive2 : public Base {

};

int main()
{
    Base base;
    Base* pb;
    Base* pb1 = new Derive();
    Base* pb2 = new Derive2();
}

（1）静态类型：

base对象的静态类型是Base；

pb指针的静态类型是Base*；

pb1指针的静态类型是Base*；

pb2指针的静态类型是Base*。

（2）动态类型：

pb1指针的动态类型是Derive。

pb2指针的动态类型是Derive2。

动态类型在运行期间可以改变。比如：

pb = pb1;
pb = pb2;

2、静态绑定、动态绑定

静态绑定：绑定的是静态类型，所对应的函数或属性依赖于对象的静态类型，发生在编译期间。

动态绑定：绑定的是动态类型，所对应的函数或属性依赖于对象的动态类型，发生在运行期间。

C++继承中的多态就是通过动态绑定实现的。要实现多态，必须存在虚函数且调用虚函数，没有虚函数就不可能存在多态。

（1）继承非虚函数

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

int main()
{
    Derive derive;
    Base* pb = &derive;
    pb->func();
}

这里的Base类指针pb指向了Derive类对象，通过指针pb调用func()函数，最终执行的是哪个类的func()函数呢？

从执行结果看，最终执行的是Base类的func()函数。

因为普通成员函数是静态绑定，类指针pb的静态类型是Base，所以调用的是Base类的func()函数。

所以，在函数重写（override）时，一定要把函数定义成virtual，否则不会产生多态效果。

（2）重新定义虚函数的参数的默认值

看下面这个例子：

class Base {
public:
    virtual void func(int i = 1) {
        cout << " Base::func() i = "<< i << endl;
    }
};
class Derive : public Base {
public:
    virtual void func(int i = 2) {
        cout << " Derive::func() i = "<< i << endl;
    }
};

int main()
{
    Derive derive;
    Base* pb = &derive;
    pb->func();
}

程序执行输出的结果如下：

Derive类的func()函数，形参i的默认值是2，这里却输出1。

因为函数参数的默认值是静态绑定的，指针pb的静态类型是Base，所以函数参数的默认值是Base类的。

3、数据成员绑定时机

（1）成员函数参数类型的确定时机

typedef string MY_TYPE;
class Base {
public:
    void func(MY_TYPE _type) {
        this->type = _type;
    }

private:
    typedef int MY_TYPE;
    MY_TYPE type;
};

这段代码编译后会报错，this->type = _type; 这行有错误。_type是string类型，this->type是int类型，类型不匹配。

从这个例子我们可以看到，成员函数的参数类型是在编译器最近一次碰到时决定的：

在func()函数之前，MY_TYPE是string类型；在变量type之前，MY_TYPE是int。

（2）成员函数的解析时机

string type;
class Base {
public:
    void func() {
        cout << typeid(type).name() << endl;
    }

private:
    int type;
};



int main()
{
    Base base;
    base.func();

    return 0;
}

程序执行后，发现打印出来的type类型是int，不是全局定义的string。

这里，我们要记住：对成员函数func的解析，是在整个类定义完后才开始的。在整个类定义完后，编译器看到了成员变量的定义：int type，所以type变量是int型，而不是全局定义的string型。