c++动态绑定与静态绑定&&effective 37条

　　多态（polymorphism）就是指不同对象收到相同消息时会执行不同的操作。通俗地讲，就是用一个相同的名字定义许多不同的函数，这些函数可以针对不同数据类型实现相同或者相似的功能，即所谓的“一个接口，多种实现”。
　　C++中的多态性与联编这一概念密切相关。一个源程序需要经过编译、连接才能形成可执行文件，在这个过程中要把调用函数名与对应函数关联在一起，这个过程就是绑定（binding），又称联编。
　　绑定分为静态绑定和动态绑定。

　　静态绑定又称静态联编，是指在编译程序时就根据调用函数提供的信息，把它所对应的具体函数确定下来，即在编译时就把调用函数名与具体函数绑定在一起。
　　动态绑定又称动态联编，是指在编译程序时还不能确定函数调用所对应的具体函数，只有在程序运行过程中才能够确定函数调用所对应的具体函数，即在程序运行时才把调用函数名与具体函数绑定在一起。
　　静态绑定：编译时绑定，通过对象调用 　　
　　动态绑定：运行时绑定，通过地址实现 C++的多态性
　　静态多态性：函数多态性——函数重载和运算符重载
　　　　　　　　模板多态性——C++模板（类模板、函数模板）
　　动态多态性：继承和虚函数，虚函数（只有用地址才能实现动态多态性）
　　只有采用“指针->函数()”或“引用变量.函数()”的方式调用C++类中的虚函数才会执行动态绑定。
　　对于C++中的非虚函数，因为其不具备动态绑定的特征，所以不管采用什么样的方式调用，都不会执行动态绑定。

　　1. 对象的静态类型：对象在声明时采用的类型。是在编译期确定的。
　　2. 对象的动态类型：目前所指对象的类型。是在运行期决定的。

　　对象的动态类型可以更改，但是静态类型无法更改。关于对象的静态类型和动态类型，看一个示例：

class B
{
}
class C : public B
{
}
class D : public B
{
}

D* pD = new D();//pD的静态类型是它声明的类型D*，动态类型也是D*
B* pB = pD;//pB的静态类型是它声明的类型B*，动态类型是pB所指向的对象pD的类型D*
C* pC = new C();
pB = pC;//pB的动态类型是可以更改的，现在它的动态类型是C*

　　3.静态绑定：绑定的是对象的静态类型，某特性（比如函数）依赖于对象的静态类型，发生在编译期。

　　4.动态绑定：绑定的是对象的动态类型，某特性（比如函数）依赖于对象的动态类型，发生在运行期。

class B
{
    void DoSomething();
    virtual void vfun();
}
class C : public B
{
    void DoSomething();//首先说明一下，这个子类重新定义了父类的no-virtual函数，这是一个不好的设计，会导致名称遮掩；这里只是为了说明动态绑定和静态绑定才这样使用。
    virtual void vfun();
}
class D : public B
{
    void DoSomething();
    virtual void vfun();
}
D* pD = new D();
B* pB = pD;

　　让我们看一下，pD->DoSomething()和pB->DoSomething()调用的是同一个函数吗？

　　不是的，虽然pD和pB都指向同一个对象。因为函数DoSomething是一个no-virtual函数，它是静态绑定的，也就是编译器会在编译期根据对象的静态类型来选择函数。pD的静态类型是D*，那么编译器在处理pD->DoSomething()的时候会将它指向D::DoSomething()。同理，pB的静态类型是B*，那pB->DoSomething()调用的就是B::DoSomething()。
　　让我们再来看一下，pD->vfun()和pB->vfun()调用的是同一个函数吗？
是的。因为vfun是一个虚函数，它动态绑定的，也就是说它绑定的是对象的动态类型，pB和pD虽然静态类型不同，但是他们同时指向一个对象，他们的动态类型是相同的，都是D*，所以，他们的调用的是同一个函数：D::vfun()。

　　上面都是针对对象指针的情况，对于引用（reference）的情况同样适用。

　　指针和引用的动态类型和静态类型可能会不一致，但是对象的动态类型和静态类型是一致的。

D D;
D.DoSomething()和D.vfun()永远调用的都是D::DoSomething()和D::vfun()。

至于那些是动态绑定，那些是静态绑定
　　我总结了一句话：只有虚函数才使用的是动态绑定，其他的全部是静态绑定。目前我还没有发现不适用这句话的，如果有错误，希望你可以指出来。
特别需要注意的地方：
　　当缺省参数和虚函数一起出现的时候情况有点复杂，极易出错。我们知道，虚函数是动态绑定的，但是为了执行效率，缺省参数是静态绑定的。

#include
using namespace std;
class Base
{
public:
    virtual int getVal(int i = 0)
    {
        cout << "基类函数" << endl;
        return i;
    }
};

class Derived :public Base
{
public:
    int getVal(int i = 1)
    {
        cout << "派生类函数" << endl;
        return i;
    }
};

int main()
{   
    Derived d;
    Base* pb = &d;
    Derived *pd = &d;
    cout << pb->getVal() << endl;
    cout << pd->getVal() << endl;
    system("pause");
    return 0;
    /*  resault:
        派生类函数
        0
        派生类函数
        1
    */
}

有上面的分析可知pD->vfun()和pB->vfun()调用都是函数D::vfun()，但是他们的缺省参数是多少？
分析一下，缺省参数是静态绑定的，pD->vfun()时，pD的静态类型是D*，所以它的缺省参数应该是20；同理，pB->vfun()的缺省参数应该是10。编写代码验证了一下，正确。
对于这个特性，估计没有人会喜欢。所以，永远记住： “绝不重新定义继承而来的缺省参数

---

effect c++条款37 绝不重新定义继承而来的缺省参数

class Base
{
public:
    virtual int getVal(int i = 0)
    {
        cout << "基类函数" << endl;
        return i;
    }
};

class Derived :public Base
{
public:
    int getVal(int i = 1)
    {
        cout << "派生类函数" << endl;
        return i;
    }
};

int main()
{   
    Derived d;
    Base* pb = &d;
    cout << pb->getVal() << endl;
    system("pause");
    return 0;
    /*  resault:
        派生类函数
        0
    */
}

　　有没有觉得很奇怪，根据动态绑定的原则，这里的确调用的是派生类的getVal函数，可是为什么会输出0呢？如果把这里的指针换成引用，也会得出相同的结果。原因出在：virtual函数是动态绑定的，但是函数的默认参数却是静态绑定的！所以当编译器看到pb是Base*这个类型时，在调用函数时，就会选择基类的默认参数。
　　这是多么容易出错的一件事啊！调用派生类的函数，但是他的参数的默认值却是基类提供的。但编译器也有自己的苦衷：运行期效率。
　　那么我们似乎应该将派生类的默认参数改成与基类相同，但是这又带来其他的问题，其中最严重的是：如果基类的默认参数需要修改，那你不得不修改所有派生类的默认参数！

一种比较好的替代方案是前面介绍的NVI手法：

class Base
{
public:
    int getVal(int i = 200)
    {
        doGetVal(i);
        return i;
    }
private:
    virtual int doGetVal(int i)
    {
        cout << "基类函数" << endl;
        return i;
    }
};

class Derived :public Base
{
private:
    virtual int doGetVal(int i=10)
    {
        cout << "派生类函数" << endl;
        return i;
    }
};
int main()
{   
    Derived d;
    Derived *pd = &d;
    Base* pb = &d;
    cout << pb->getVal() << endl;
    cout << pd->getVal() << endl;
    system("pause");
    /*  resault:
            派生类函数
            200
            派生类函数
            200
    */
    return 0;

}

　　此时，基类和派生类就使用了共同的默认参数了。
　　总之，virtual函数是动态绑定，但是函数的默认参数是静态绑定的。所以绝不要重新定义派生类的函数的默认参数值，而且最好使用NVI手法。