C++多态

多态

多态即多种状态，在面向对象语言中，接口的多种不同的实现方式即为多态，多态分为两种一种为静态多态，一种为动态多态，静态多态是通过函数重载实现的，在程序链接期间已经绑定，动态多态是通过虚函数实现，在程序运行期间通过调用的对象决定执行的函数。

虚函数

虚函数是通过virtual定义的
要实现多态必须重写虚函数，重写是指在基类中有一个和子类返回值、函数名、参数相同的虚函数，子类的虚函数可以重写基类虚函数，也叫做覆盖，和重载不同的是重载需要在同一作用域，并且重载不要求返回值相同，另外还有一个是重定义或者叫隐藏，即在基类和派生类中有相同的函数名，但是其参数或者返回值不同的函数。另外还有两个例外就是协变和抗变其返回值不同但是构成重写
在虚函数后面添加 = 0这个函数为纯虚函数，包含纯虚函数的类为抽象类或者接口类，其不能实例化对象，并且抽象类的派生类如果没有重写纯虚函数，其也不能实例化对象。

多态的实现原理

看一个例子

class Base
{
public:
	virtual void Func1()
	{
		cout << "Func1()" << endl;
	}
private:
	int _b = 1;
};

这个类通过sizeof计算的大小为８而类的成员函数只有一个整型
在vs写可以通过监视窗口看到类的成员中还有一个指针__vfptr其类型为void **

这个指针就是虚表指针，
然后看另一个例子

class Base
{
public:
	virtual void Func1()
	{
		cout << "Base::Func1()" << endl;
	}
	virtual void Func2()
	{
		cout << "Base::Func2()" << endl;
	}
	void Func3()
	{
		cout << "Base::Func3()" << endl;
	}
private:
	int _b = 1;
};
class Derive : public Base
{
public:
	virtual void Func1()
	{
		cout << "Derive::Func1()" << endl;
	}
private:
	int _d = 2;
};

int main()
{
	Base b;
	Derive d;
	return 0;
}

可以看到派生类也有一个虚表指针，并且这个指针是继承基类的，然后看两个基表指针值是不同的所以其指向两个不同的基表，就是说每个派生类均有自己的基表，然后看内容其中第一个函数地址不同，第二个相同，因为第一个函数已经被重写，基表在生成时会复制父类的基表，如果有函数被重写则改变其值换成当前类中该函数的指针，没有重写则不变。
通过这种方法实现不同的对象调用虚函数会执行不同的函数，其每次调用时均会在自己的虚表中查找该函数对应的地址，
另外需要注意多继承中虚函数表的问题
因为在vs监视窗口有显示bug所以用程序打印虚表如下

class Base1 {
public:
	virtual void func1() { cout << "Base1::func1" << endl; }
	virtual void func2() { cout << "Base1::func2" << endl; }
private:
	int b1;
};
class Base2 {
public:
	virtual void func1() { cout << "Base2::func1" << endl; }
	virtual void func2() { cout << "Base2::func2" << endl; }
private:
	int b2;
};
class Derive : public Base1, public Base2 {
public:
	virtual void func1() { cout << "Derive::func1" << endl; }
	virtual void func3() { cout << "Derive::func3" << endl; }
private:
	int d1;
};
typedef void(*VFPTR) ();
void PrintVTable(VFPTR vTable[])
{
	cout << " 虚表地址>" << vTable << endl;
	for (int i = 0; vTable[i] != nullptr; ++i)
	{
		printf(" 第%d个虚函数地址 :0X%x,->", i, vTable[i]);
		VFPTR f = vTable[i];
		f();
	}
	cout << endl;
}
int main()
{
	Derive d;
	Base1 a;
	Base2 b;

	//base1
	VFPTR* vTableb1 = (VFPTR*)(*(int*)&a);
	PrintVTable(vTableb1);

	//base2
	VFPTR* vTableb2 = (VFPTR*)(*(int*)&b);
	PrintVTable(vTableb2);

	//Derive
	VFPTR* vTableb3 = (VFPTR*)(*(int*)&d);
	PrintVTable(vTableb3);
	VFPTR* vTableb4 = (VFPTR*)(*(int*)((char*)&d + sizeof(Base1)));
	PrintVTable(vTableb4);
	system("pause");
	return 0;
}

结果为：

可以看到几点，首先在派生类中含有两个虚表，即每个基类对应一个，另外派生类中的虚函数会添加到第一个基表中，即在继承时按顺序第一个，并且重写后会覆盖所有基类中的相同函数，而且每个基类对应的函数地址不相同。

最后就是多态需要注意的几个问题

1. 普通函数不能定义为虚函数（非成员函数）
2. 静态函数不能定义为虚函数，因为静态成员函数没有this指针，其使用对象调用就没法通过对象中的虚表确认是哪个函数
3. 构造函数不能定义为虚函数，因为构造函数在执行前，此时对象还没有定义，此时虚表指针还不存在
4. 如果虚函数表现多态性不能定义为内联，因为如果函数确定为内联其是没有函数地址的，并且内联是在编译时就会加入到函数体内
5. 析构函数建议定义成虚函数（如果类准备继承其他类），因为如果父类指针指向子类对象，然后通过delete去释放，此时会调用父类的析构函数可能会存在内存泄露等问题，如果是虚函数则调用子类对象；