博客标题：C++中的静态与动态绑定：一场编译与运行时的较量-优快云博客

本文链接：https://blog.youkuaiyun.com/wgr050505/article/details/140305758

引言

C++在面向对象编程中，存在着静态绑定和动态绑定的定义，本节即是主要讲述这两点区分。
我是在一个类的继承体系中分析的，因此下面所说的对象一般就是指一个类的实例。
首先我们需要明确几个名词定义：

静态类型：对象在声明时采用的类型，在编译期既已确定；
动态类型：通常是指一个指针或引用目前所指对象的类型，是在运行期决定的；
静态绑定：绑定的是静态类型，所对应的函数或属性依赖于对象的静态类型，发生在编译期；
动态绑定：绑定的是动态类型，所对应的函数或属性依赖于对象的动态类型，发生在运行期；

从上面的定义也可以看出，非虚函数一般都是静态绑定，而虚函数都是动态绑定（如此才可实现多态性）。
先看代码和运行结果：

class A
{
public:
    /*virtual*/ void func(){ std::cout << "A::func()\n"; }
};
class B : public A
{
public:
    void func(){ std::cout << "B::func()\n"; }
};
class C : public A
{
public:
    void func(){ std::cout << "C::func()\n"; }
};

下面逐步分析测试代码及结果，

 C* pc = new C(); //pc的静态类型是它声明的类型C*，动态类型也是C*；
 B* pb = new B(); //pb的静态类型和动态类型也都是B*；
 A* pa = pc;      //pa的静态类型是它声明的类型A*，动态类型是pa所指向的对象pc的类型C*；
 pa = pb;         //pa的动态类型可以更改，现在它的动态类型是B*，但其静态类型仍是声明时候的A*；
 C *pnull = NULL; //pnull的静态类型是它声明的类型C*,没有动态类型，因为它指向了NULL；

如果明白上面代码的意思，请继续，

 pa->func();      //A::func() pa的静态类型永远都是A*，不管其指向的是哪个子类，都是直接调用A::func()；
 pc->func();      //C::func() pc的动、静态类型都是C*，因此调用C::func()；
 pnull->func();   //C::func() 不用奇怪为什么空指针也可以调用函数，因为这在编译期就确定了，和指针空不空没关系；

如果注释掉类C中的func函数定义，其他不变，即

 class C : public A
 {
 };
 
 pa->func();      //A::func() 理由同上；
 pc->func();      //A::func() pc在类C中找不到func的定义，因此到其基类中寻找；
 pnull->func();   //A::func() 原因也解释过了；

如果为A中的void func()函数添加virtual特性，其他不变，即

 class A
 {
 public:
     virtual void func(){ std::cout << "A::func()\n"; }
 };
 
 pa->func();      //B::func() 因为有了virtual虚函数特性，pa的动态类型指向B*，因此先在B中查找，找到后直接调用；
 pc->func();      //C::func() pc的动、静态类型都是C*，因此也是先在C中查找；
 pnull->func();   //空指针异常，因为是func是virtual函数，因此对func的调用只能等到运行期才能确定，然后才发现pnull是空指针；

分析：
在上面的例子中，

1. 如果基类A中的func不是virtual函数，那么不论pa、pb、pc指向哪个子类对象，对func的调用都是在定义pa、pb、pc时的静态类型决定，早已在编译期确定了。

同样的空指针也能够直接调用no-virtual函数而不报错（这也说明一定要做空指针检查啊！），因此静态绑定不能实现多态；

2. 如果func是虚函数，那所有的调用都要等到运行时根据其指向对象的类型才能确定，比起静态绑定自然是要有性能损失的，但是却能实现多态特性；

本文代码里都是针对指针的情况来分析的，但是对于引用的情况同样适用。

至此总结一下静态绑定和动态绑定的区别：
1. 静态绑定发生在编译期，动态绑定发生在运行期；

2. 对象的动态类型可以更改，但是静态类型无法更改；

3. 要想实现动态，必须使用动态绑定；

4. 在继承体系中只有虚函数使用的是动态绑定，其他的全部是静态绑定；

建议：

绝对不要重新定义继承而来的非虚(non-virtual)函数（《Effective C++ 第三版》条款36），因为这样导致函数调用由对象声明时的静态类型确定了，而和对象本身脱离了关系，没有多态，也这将给程序留下不可预知的隐患和莫名其妙的BUG；

另外，在动态绑定也即在virtual函数中，要注意默认参数的使用。当缺省参数和virtual函数一起使用的时候一定要谨慎，不然出了问题怕是很难排查。
看下面的代码：

class E
{
public:
    virtual void func(int i = 0)
    {
        std::cout << "E::func()\t"<< i <<"\n";
    }
};
class F : public E
{
public:
    virtual void func(int i = 1)
    {
        std::cout << "F::func()\t" << i <<"\n";
    }
};

void test2()
{
    F* pf = new F();
    E* pe = pf;
    pf->func(); //F::func() 1  正常，就该如此；
    pe->func(); //F::func() 0  哇哦，这是什么情况，调用了子类的函数，却使用了基类中参数的默认值！
}

静态绑定：编译时的智慧

静态绑定发生在编译阶段，它基于类型信息确定函数或方法的具体实现。这意味着在编译时，编译器已经知道了所有可能的调用路径，并且可以生成相应的机器码。

示例1：函数重载

#include <iostream>

void print(int x) {
    std::cout << "Integer: " << x << std::endl;
}

void print(double x) {
    std::cout << "Double: " << x << std::endl;
}

int main() {
    print(5);       // 调用 print(int)
    print(5.0);     // 调用 print(double)
    return 0;
}

在这个例子中，print函数的调用是根据参数类型在编译时决定的，这就是静态绑定。

示例2：结构体成员访问

struct A {
    int x;
};

int main() {
    A a;
    a.x = 10;       // 成员访问也是静态绑定
    return 0;
}

动态绑定：运行时的选择

动态绑定则是在程序执行过程中，根据对象的实际类型来决定调用哪个方法。这主要通过虚函数和继承实现。

示例3：虚函数

class Base {
public:
    virtual void print() const {
        std::cout << "Base class" << std::endl;
    }
};

class Derived : public Base {
public:
    void print() const override {
        std::cout << "Derived class" << std::endl;
    }
};

int main() {
    Base* basePtr = new Derived();
    basePtr->print();   // 运行时决定调用Derived::print()
    delete basePtr;
    return 0;
}

在这个例子中，尽管basePtr是一个Base类型的指针，但它指向的是一个Derived类型的对象。因此，当调用print()时，实际调用的是Derived类中的print()，这是动态绑定的典型示例。