1.动态绑定与静态绑定

  • 为了支持c++的多态性，才用了动态绑定和静态绑定。理解他们的区别有助于更好的理解多态性，以及在编程的过程中避免犯错误。需要理解四个名词：
    • 对象的静态类型：对象在声明时采用的类型，是在编译期确定的。
    • 对象的动态类型：目前所指对象的类型，是在运行期决定的。对象的动态类型可以更改，但是静态类型无法更改。
      • 关于对象的静态类型和动态类型，示例如下：
            #include "iostream"

    using namespace std;


    // 对象的动态与静态类型
    class B{

    };


    class C: public B{

    };

    class D:public B{

    };


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

        return 0;
    }
    • 静态绑定：绑定的是对象的静态类型，某特性（比如函数）依赖于对象的静态类型，发生在编译期
    • 动态绑定：绑定的是对象的动态类型，某特性（比如函数）依赖于对象的动态类型，发生在运行期
      • 关于静态绑定和动态绑定，示例如下：
            #include "iostream"


    using namespace std;

    class B{
        public:
            void DoSomething(){
                cout << "B DoSomething()......\n";
            }
            virtual void vfun(){
                cout << "B vfun()......\n";
            }
    };


    class C: public B{
        public:
            void DoSomething(){  // 首先说明一下，这个子类重新定义了父类的no-virtual函数，这是一个不好的设计，会导致名称隐藏；这里只是为了说明动态绑定和静态绑定才这样使用。
                cout << "C DoSomething().....\n";
            }
            virtual void vfun(){
                cout << "C vfun()......\n";
            }
    };

    class D:public B{
        public:
            void DoSomething(){
                cout << "D DoSomething().....\n";
            }
            virtual void vfun(){
                cout << "D vfun()......\n";
            }
    };

    int main(){
        // 静态绑定
        D *pD = new D();
        B *pB = pD;
        pD->DoSomething();
        pB->DoSomething();
        // 动态绑定
        pD->vfun();
        pB->vfun();
        return 0;
    }
    • 解释: 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()。
  • 总结:只有虚函数才使用的是动态绑定，其他的全部是静态绑定。

2.注意的地方

  • 当缺省参数和虚函数一起出现的时候情况有点复杂，极易出错。我们知道虚函数是动态绑定的，但是为了执行效率，缺省参数是静态绑定的。
        #include "iostream"


    using namespace std;


    // 对象的动态与静态类型
    class B{
        public:
            void DoSomething(){
                cout << "B DoSomething()......\n";
            }
            virtual void vfun(){
                cout << "B vfun()......\n";
            }
            // 缺省参数和虚函数一起出现，是静态绑定！
            virtual void func(int i = 20){
                cout << "B func()......\n";
            }
    };


    class C: public B{
        public:
            void DoSomething(){  // 首先说明一下，这个子类重新定义了父类的no-virtual函数，这是一个不好的设计，会导致名称隐藏；这里只是为了说明动态绑定和静态绑定才这样使用。
                cout << "C DoSomething().....\n";
            }
            virtual void vfun(){
                cout << "C vfun()......\n";
            }
            virtual void func(){
                cout << "C func()......\n";
            }
    };

    class D:public B{
        public:
            void DoSomething(){
                cout << "D DoSomething().....\n";
            }
            virtual void vfun(){
                cout << "D vfun()......\n";
            }
            virtual void func(){
                cout << "D func()......\n";
            }
    };



    int main(){
        // 缺省参数和虚函数一起出现,是静态绑定！
        D *pD = new D();
        B* pB = pD;
        pD->func();
        pB->func();
        return 0;
    }
  • 解释：缺省参数是静态绑定的，pD->vfun()时，pD的静态类型是D*，所以它的缺省参数应该是20；同理，pB->vfun()的缺省参数应该是10。