99、静态类型和动态类型,静态绑定和动态绑定的介绍

2021/7/11 6:07:38

本文主要是介绍99、静态类型和动态类型,静态绑定和动态绑定的介绍,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

1.静态类型:对象在声明时采用的类型,在编译期既已确定;

2.动态类型:通常是指一个指针或引用目前所指对象的类型,是在运行期决定的;

3.静态绑定:绑定的是静态类型,所对应的函数或属性依赖于对象的静态类型,发生在编译期;

4.动态绑定:绑定的是动态类型,所对应的函数或属性依赖于对象的动态类型,发生在运行期;

 

从上面的定义也可以看出,非虚函数一般都是静态绑定,而虚函数都是动态绑定(如此才可实现多态 性)。

 

#include <iostream>
using namespace std;
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"; }
};
int main()
{
    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() 不用奇怪为什么空指针也可以调用函数,因为这在编译期就确定了,和指针空不空没关系;
    return 0;
}

如果将A类中的virtual注释去掉,则运行结果是:
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时的静态类型决定,早已在编译期确定了。
2.同样的空指针也能够直接调用no-virtual函数而不报错(这也说明一定要做空指针检查啊!),
因此静态绑定不能实现多态;
3.如果func是虚函数,那所有的调用都要等到运行时根据其指向对象的类型才能确定,比起静态绑 
定自然是要有性能损失的,但是却能实现多态特性;

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

至此总结一下静态绑定和动态绑定的区别:
1.静态绑定发生在编译期,动态绑定发生在运行期; 
2.对象的动态类型可以更改,但是静态类型无法更改; 
3.要想实现动态,必须使用动态绑定; 
4.在继承体系中只有虚函数使用的是动态绑定,其他的全部是静态绑定;

绝对不要重新定义继承而来的非虚(non-virtual)函数(《Effective C++ 第三版》条款36),
因为这样导致函数调用由对象声明时的静态类型确定了,而和对象本身脱离了关系,没有多态,
也这将给程序留下不可预知的隐患和莫名其妙的BUG;另外,在动态绑定也即在virtual函数中,
要注意默认参数的使用。 当缺省参数和virtual函数一起使用的时候一定要谨慎,
不然出了问题怕是很难排查。 (虚函数中一般不要使用默认参数)
看下面的代码:
#include <iostream>
using namespace std;
class E
{
public:
    virtual void func(int i = 0)
    {

        std::cout << "E::func()\t" << i << "\n";
    }
};
class F : public E{
public:
    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 哇哦,这是什么情况,调用了子类的函数,却使用了基类中参数的默认值!
}
int main()
{
    test2();
    return 0;
}


这篇关于99、静态类型和动态类型,静态绑定和动态绑定的介绍的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!


扫一扫关注最新编程教程