C++动态绑定

作为一个程序员，本职就是写代码。像一个作家一样在战斗~

来看例子一

class Base{public:Base(){printf("Base\n");}void foo(){printf("Base::foo\n");}~Base(){printf("~Base\n");}};class Derived:public Base{public:Derived(){printf("Derived\n");}void foo(){printf("Derived::foo\n");}~Derived(){printf("~Derived\n");}};int _tmain(int argc, _TCHAR* argv[]){Base *base=new Derived();base->foo();delete base;

例子一的输出是什么？为什么呢？

先构造父类，再构造子类，调用父类的方法，析构父类

居然没有析构子类！！！为什么呢？

如果把父类的foo函数加virtual关键字，其他都不变

virtual void foo(){printf("Base::foo\n");}

那运行的结果是：

此时调用的是子类的foo函数，但是依然没有析构子类！

我们再把父类的析构函数加上virtual关键字

virtual ~Base(){printf("~Base\n");}

此时运行的结果是：

此时可以正确执行子类的析构方法了！

 

动态绑定是为C++的多态性而生，而多态性可以简单成“一个接口，多个方法”，程序在运行时才决定调用哪个函数，那么这种多态性是怎么实现的呢？

C++的多态性是通过虚函数来实现的。虚函数允许子类重新定义父类的成员函数。

多态与非多态的实质区别就是函数地址是早绑定还是晚绑定。如果在编译时就绑定，即静态绑定，那就是早绑定。如果函数地址在编译时不能确定，要在运行时绑定，那就属于晚绑定。

编译时、运行时？

封装使得代码模块化、继承可以扩展已经存在的代码，目的都是为了代码重用。多态是为了接口重用，一个接口或者父类指针就可以调用传过来的具体对象的实现方法。

C++支持两种多态性，编译时多态性，运行时多态性。

编译时多态性是通过重载函数来实现。

运行时多态性是通过虚函数来实现。

来看看另外一个题目

class M{public:void foo(){printf("1\n");}virtual void fun(){printf("2\n");}};class N:public M{public:void foo(){printf("3\n");}void fun(){printf("4\n");}};int _tmain(int argc, _TCHAR* argv[]){M m;N n;M *p=&m;p->foo();p->fun();p=&n;p->foo();p->fun();//用子类指针访问父类N *q=(N*)&m;q->foo();q->fun();

这代码执行完的输出结果是什么？

最后用子类的指针去访问父类的函数时，我的理解是foo函数不是虚函数，只要不是虚函数就是静态绑定，那么就要看用子类还是父类的指针去访问跟其静态绑定的函数;

fun是虚函数，虚函数就是动态绑定，那么就要看传进来的对象是父类还是子类，执行动态绑定的函数。

M m;N n;n.fun();((M)n).fun();//((N)m).fun();不存在用户定义的从M到N的适当转换((M*)&n)->fun();((N*)&m)->fun();

假如我们这样调用，输出的结果是：

这里涉及到强制类型转换及通过“.”和“->”调用的区别