滴水逆向——C++_动态绑定/多态

1、绑定概念
1.什么是绑定？
绑定就是将函数调用与地址关联起来.
观察下面代码反汇编

class Base				
{				
public:				
	int x;			
public:				
	Base()			
	{			
		x = 100;		
	}			
    void Function_1()				
    {				
        printf("Base:Function_1...\n");				
    }				
    virtual void Function_2()				
    {				
        printf("Base:Function_2...virtual\n");				
    }				
};				
class Sub:public Base				
{				
public:				
	int x;			
public:				
	Sub()			
	{			
		x = 200;		
	}			
    void Function_1()				
    {				
        printf("Sub:Function_1...\n");				
    }				
    virtual void Function_2()				
    {				
        printf("Sub:Function_2...virtual\n");				
    }				
};				
				
void TestBound(Base* pb)				
{				
	int n = pb->x;			
	printf("%x\n",n);			
				
	pb->Function_1();		//函数调用	
				
	pb->Function_2();			
}				
int main(int argc, char* argv[])				
{				
    				
				
	return 0;			
}				

2.什么是前期绑定？什么是后期绑定、动态绑定、运行期绑定？

总结：
           只有virtual的函数是动态绑定.
           动态绑定还有一个名字：多态

1、虚函数表：

struct Base							
{							
public:							
    virtual void Function_1()							
    {							
        printf("Function_1...\n");							
    }							
    virtual void Function_2()							
    {							
        printf("Function_2...\n");							
    }							
    virtual void Function_3()							
    {							
        printf("Function_3...\n");							
    }							
};							
							
							
							
int main(int argc, char* argv[])							
{							
	//查看 Base 的虚函数表						
    Base base;							
							
	//对象的前四个字节就是虚函数表						
	printf("Base 的虚函数表地址为：%x\n",*(int*)&base);						
							
	//虚函数表中第1个函数地址						
	printf("虚函数表中第1个函数地址：%x\n",*((int*)(*(int*)&base)+0));						
	//虚函数表中第2个函数地址						
	printf("虚函数表中第2个函数地址：%x\n",*((int*)(*(int*)&base)+1));						
	//虚函数表中第3个函数地址						
	printf("虚函数表中第3个函数地址：%x\n",*((int*)(*(int*)&base)+2));						
							
	//通过函数指针调用函数，验证正确性						
	typedef void(*pFunction)(void);						
							
	pFunction pFn;						
	pFn = (pFunction)*((int*)(*(int*)&base)+0);						
	pFn();						
	pFn = (pFunction)*((int*)(*(int*)&base)+1);						
	pFn();						
	pFn = (pFunction)*((int*)(*(int*)&base)+2);						
	pFn();						
							
	return 0;						
}							

2、单继承无函数覆盖

struct Base							
{							
public:							
    virtual void Function_1()							
    {							
        printf("Base:Function_1...\n");							
    }							
    virtual void Function_2()							
    {							
        printf("Base:Function_2...\n");							
    }							
    virtual void Function_3()							
    {							
        printf("Base:Function_3...\n");							
    }