C++动态绑定-多态

绑定：

        绑定就是将函数调用与地址关联起来。

1. 普通的成员变量、成员函数、编译完的时候，调用地址就确定好的。
2. virtual函数的地址是不确定的，只是能确定虚表的地址，virtual函数有可能被重写。
3. 只有virtual的函数是动态绑定。
4. 动态绑定还有一个名字：多态。
5. 常用场景：析构函数定义为虚函数。 （否则定义父类指针去访问子类，最后可能释放的是父类的空间而不是子类的空间，从而出错）。
6. 如果使用父类指针去访问子类的方法(函数)，只有一个办法就是多态virtual。

#include<stdio.h>

class Base
{
public:
	int x;
	Base()
	{
		x = 100;
	}
	void fun1(void)
	{
		printf("Base : fun1 \n ");
	}
	virtual void fun2(void)
	{
		printf("Base : virtual fun2\n");
	}
};
class Sub:public Base
{
public:
	int x;
	Sub()
	{
		x= 200;
	}
		void fun1(void)
	{
		printf("Sub : fun1 \n ");
	}
	virtual void fun2(void)
	{
		printf("Sub : virtual fun2\n");
	}
};

void test(Base * pb)
{
	int x = pb->x;
	printf("x = %d\n",x);
	pb->fun1();
	pb->fun2();//提现出了不同的行为，称为多态。
}

int main(int argc,char *argv[])
{
	Base pb;
	test(&pb);

	Sub ps;
	test(&ps);
	return 0;
}

此程序没有使用virtual多态，每次调用只会调用父类的printf()函数。

运行结果：

Base: 100  200
Base: 111  222
Base: 77  88
Press any key to continue

#include<stdio.h>

class Base
{
public:
	int x;
	int y;
	Base()
	{
		x = 100;
		y = 200;
	}
	void Print()
	{
		printf("Base: %d  %d\n",x,y);
	}
};
class Sub1:public Base
{
public:
	int a;
	Sub1()
	{
		x = 111;
		y = 222;
		a = 333;
	}
	void Print()
	{
		printf("sub1: %d  %d\n",x,y,a);
	}
};
class Sub2:public Base
{
public:
	int b;
	Sub2()
	{
		x = 77;
		y = 88;
		b = 66;
	}
	void Print()
	{
		printf("sub2: %d  %d\n",x,y,b);
	}
};

void test(void)
{
	Base b;
	Sub1 s1;
	Sub2 s2;
	Base* arr[] = {&b,&s1,&s2};
	int i;
	for(i=0; i<3;i++)
	{
		arr[i]->Print();
	}
}

int main(int argc,char *argv[])
{
	test();
	return 0;
}

加上virtual，使之提现多态性后，结果如下：

Base: 100  200
sub1: 111  222  333
sub2: 77  88  66
Press any key to continue