浅谈C++多态

多态是什么呢？

Step1:多态的概念：通俗的讲，就是同一个东西表现出不同的形态。一个接口，多种方法。

举个例子：买车票，车票分为学生票和成人票，一个人为了去往目的地，可以选择买成人票，也可以选择买学生票。

Step2:多态分为两种

1.静态多态（发生在编译阶段）

函数重载

编译器根据实参的类型推断出需要调用哪个函数，如有对应的函数就调用，否则就会出现编译错误。

int Add(int a, int b)
{
	return a + b;
}
float Add(float a, float b)
{
	return a + b;
}
int main()
{
	int add1 = Add(1, 2);
	float add2 = Add(1.5f, 3.4f);
	cout << add1 << endl;
	cout << add2 << endl;
	system("pause:");
	return 0;
}

泛型编程

指的是与类型无关的编程。后边的博客中我们专门会对这一部分进行详细解释。

2.动态多态（发生在程序运行时）

条件1.虚函数 --->一定在派生类对基类虚函数进行重写；条件2.通过基类的指针或引用调用虚函数。

class Base
{
public:
	virtual void FunTest1()
	{
		cout << "Base::FunTest1()" << endl;
	}
	virtual void FunTest2()
	{
		cout << "Base::FunTest2()" << endl;
	}

	int _b;
};

class Derived:public Base
{
public:
	virtual void FunTest1()
	{	
		cout << "Dervired::FunTest1()" << endl;
	}
	virtual void FunTest3()
	{
		cout << "Dervired::FunTest3()" << endl;
	}

	int _d;
};

typedef void(*FunSrc)();

void print(Base&b)//打印函数
{
	FunSrc* pfun = (FunSrc*)(*(int*)&b);
	while (*pfun)
	{
		(*pfun)();
		pfun++;
	}
}

void print(Base&b)//打印函数
{
	FunSrc* pfun = (FunSrc*)(*(int*)&b);
	while (*pfun)
	{
		(*pfun)();
		pfun++;
	}
}

int main()
{
	Derived d;
	Derived& d1 = d;
	print(d1);
	system("pause:");
	return 0;
}

分析如下：

注意：调用虚函数的时候需要通过基类的指针或引用。

函数重载&函数重写

函数重载：在同一作用域中，函数名相同，函数列表不同的函数。

函数重写：不在同一作用域，在继承体系中，若基类中有虚函数，在派生类中有和基类虚函数原型完全相同的函数，一般情况下，函数返回值类型相同，除了两个特例。

①协变

我们把派生类中重写的虚函数返回值改变，编译器报错。

因此，重写要求返回值类型相同，但协变对于这个规则将会放宽。

协变:在C++中，原来的返回值类型为基类的指针或引用，新的返回值类型为派生类的指针或引用。

class Base
{
public:
	virtual Base& FunTest1()
	{
		cout << "Base::FunTest1()" << endl;
		return *this;
	}
	virtual void FunTest2()
	{
		cout << "Base::FunTest2()" << endl;
	}

	int _b;
};

class Derived:public Base
{
public:
	virtual Derived& FunTest1()
	{	
		cout << "Dervired::FunTest1()" << endl;
		return *this;
	}
	virtual void FunTest3()
	{
		cout << "Dervired::FunTest3()" << endl;
	}

	int _d;
};

②析构

class Base
{
public:
	virtual ~Base()
	{
		cout << "Base()" << endl;
	}

	int _b;
};

class Derived:public Base
{
public:
	virtual ~Derived()
	{
		cout << "~Derived" << endl;
	}
	
	int _d;
};

--->函数重写时最好将基类中的函数给成虚函数。

--->构造函数不能作为虚函数。

--->纯虚函数(在成员函数形参后边加上=0，这样的函数称为纯虚函数)，包含纯虚函数的类叫做抽象类。

举个例子：

class Base
{
public:
	virtual void Display() = 0;
	
	int _b;
};

Step3: 虚表中虚函数的排列顺序       

1.单继承

①按照虚函数在基类的顺序将虚函数拷贝一份；

②检测派生类中是否对基类中虚函数进行重写--->若是检测到重写，用派生类中重写的虚函数来替换相同偏移位置的基类虚函数。

③在虚表之后添加派生类自己的虚函数。

注：在一些编译环境下，会在虚表的末尾加四个字节（00 00 00 00）。

2.多继承

④先继承的基类的虚表在前，将派生类自己的新增加的虚函数补充到第一张虚表的末尾。

class Base1
{
public:
	virtual void FunTest1()
	{
		cout << "Base1::FunTest1()" << endl;
	}
	virtual void FunTest2()
	{
		cout << "Base1::FunTest2()" << endl;
	}

	int _b1;
};

class Base2
{
public:
	virtual void FunTest1()
	{
		cout << "Base2::FunTest1()" << endl;
	}
	virtual void FunTest3()
	{
		cout << "Base2::FunTest3()" << endl;
	}

	int _b2;
};

class Derived :public Base1, public Base2
{
public:
	virtual void FunTest1()
	{
		cout << "Derived::FunTest1()" << endl;
	}
	virtual void FunTest4()
	{
		cout << "Derived::FunTest4()" << endl;
	}


	int _d;
};

typedef void(*FunSrc)();

void print(Base1&b)//打印函数
{
	FunSrc* pfun = (FunSrc*)(*(int*)&b);
	while (*pfun)
	{
		(*pfun)();
		pfun++;
	}
}

void print(Base2&b)//打印函数
{
	FunSrc* pfun = (FunSrc*)(*(int*)&b);
	while (*pfun)
	{
		(*pfun)();
		pfun++;
	}
}

int main()
{
	Derived d;
	d._b1 = 0;
	d._b2 = 1;
	d._d = 2;
	Base1&b1 = d;
	print(b1);
	Base2&b2 = d;
	print(b2);
	system("pause:");
	return 0;
}

分析如下：

较复杂的还有虚拟继承和虚函数的结合，以及菱形虚拟继承，我们会在下一篇进行详细的讲解分析，谢谢！