多态的原理探究和父类子类步长

一.多态是如何实现的

首先用文字叙述：

1.当类中声明虚函数时，编译器会在类中生成一个虚函数表

2.虚函数表是一个存储类成员函数指针的数据结构

3.虚函数表是由编译器自动生成与维护的

4.virtual成员函数会被编译器放入虚函数表中

5.当存在虚函数时，每个对象中都有一个指向虚函数的指针（C++编译器给父类对象，子类对象提前布局vptr指针），当进行test(parent *base)函数的时候，C++编译器不需要区分子类或者父类对象，只需要再base指针中，找到vptr指针即可）

6.vptr一般作为类对象的第一个成员

下来根据代码分析：

class parent
{
public:
	virtual void fun()
	{
		cout << "我是父类..." << endl;
	}
};
class child:public parent
{
public:
	virtual void fun()
	{
		cout << "我是子类..." <<  endl;
	}
};
void test(parent *base)//只需要根据对象中的vptr指针来找虚函数表，找函数入口地址，调用函数，实现多态，实现迟绑定效果
{
	base->fun();
}
int main()
{
	parent c1;//用类定义对象的时候，C++编译器会在对象中添加一个vptr指针
	child c2;
	test(&c1);
	test(&c2);
	system("pause");
	return 0;
}

二.如何证明vptr指针的存在
测试加vitual的类和没有vitual类的大小看看是不是差四个字节。

三.构造函数中调用虚函数，能实现多态吗？

class parent
{
public:
	parent(int a = 10)
	{
		this->a = a;
		fun();//调用子类的fun函数还是父类的fun函数
	}
	virtual void fun()
	{
		cout << "我是父类..." << endl;
	}
private:
	int a;
};
class child:public parent
{
public:
	child(int b = 20) :parent(15)
	{
		this->b = b;
	}
	virtual void fun()
	{
		cout << "我是子类..." <<  endl;
	}
private:
	int b;
};
int main()
{
	child c2;//定义了一个子类对象调用父类构造函数，在父类构造函数中调用虚函数能发生多态吗？
	system("pause");
	return 0;
}

在这样试试：

class parent
{
public:
	parent(int a = 10)
	{
		this->a = a;
		
	}
	virtual void fun()
	{
		cout << "我是父类..." << endl;
	}
private:
	int a;
};
class child:public parent
{
public:
	child(int b = 20) :parent(15)
	{
		this->b = b;
		fun();//调用子类的fun函数还是父类的fun函数
	}
	virtual void fun()
	{
		cout << "我是子类..." <<  endl;
	}
private:
	int b;
};
int main()
{
	child c2;//定义了一个子类对象调用父类构造函数，在父类构造函数中调用虚函数能发生多态吗？
	system("pause");
	return 0;
}

但是很明显没有发生多态现象~

为什么呢。这就涉及到了vpt指针的初始化，因为vptr指针是分步初始化的，接下来我画图说明

四.父类指针和子类指针步长问题？

 首先，我们来看如下代码：

class parent
{
public:
	parent(int a = 10)
	{
		this->a = a;
	}
	virtual void fun()
	{
		cout << "我是父类..." << endl;
	}
private:
	int a;
};
class child:public parent
{
public:
	child(int b = 20) :parent(15)
	{
		//this->b = b;
	}
	virtual void fun()
	{
		cout << "我是子类..." <<  endl;
	}
private:
	//int b;
};
int main()
{
	child c2;
	parent *p1 = NULL;
	child *p2 = NULL;
	child arr[] = { child(1), child(2), child(3) };
	p1 = arr;//父类指针指向arr
	p2 = arr;//子类指针指向arr
	p1->fun();
	p2->fun();
	p1++;
	p2++;
	p1->fun();
	p2->fun();
	system("pause");
	return 0;
}

在执行过程中会出现什么问题呢？结果如下：

我们会发现程序崩溃了！这是为什么呢？

接下来我们再把child类里面的成员b屏蔽了,

class parent
{
public:
	parent(int a = 10)
	{
		this->a = a;
	}
	virtual void fun()
	{
		cout << "我是父类..." << endl;
	}
private:
	int a;
};
class child:public parent
{
public:
	child(int b = 20) :parent(15)
	{
		//this->b = b;
	}
	virtual void fun()
	{
		cout << "我是子类..." <<  endl;
	}
private:
	//int b;
};
int main()
{
	child c2;
	parent *p1 = NULL;
	child *p2 = NULL;
	child arr[] = { child(1), child(2), child(3) };
	p1 = arr;//父类指针指向arr
	p2 = arr;//子类指针指向arr
	p1->fun();
	p2->fun();
	p1++;
	p2++;
	p1->fun();
	p2->fun();
	system("pause");
	return 0;
}

再运行看结果：

这样就通过了，为什么呢？

这就是因为父类指针步长和子类步长不一样。

接下来我就画图解释一下：