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();

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

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