【C++多态】

---

多态的概念

C++中，多态可以理解为多种形态，每中形态完成不同的工作。不同的对象完成不同的具体行为。比如说有多种交通工具，都是方便人们出行的，比如汽车和船，一个只能在地上跑，另一个只能在水里开。有一个交通工具的类，如果有了交通工具，就可以去出行，如果是汽车，可以通过汽车出行，如果是船，可以通过船出行。不同的对象使用不同的出行方式。这就是多态。什么样的对象，然后以相对应的方式执行。

class Pileup
{
public:
	virtual void fun() {
		cout << "交通工具:tourism" << endl;//出行
	}//虚函数fun
	virtual ~Pileup() {
	cout << "~Pileup()" << endl;
	}
private:
	int price = 0;
};
class Car : public Pileup
{
public:
	virtual void fun() {
		cout << "汽车:tourism by car" << endl;//汽车方式出行	
	}
	~Car() {
	cout << "~Car()" << endl;
	}
private:
	int price = 0;
};
class Plane : public Pileup
{
public:
	virtual void fun() {
		cout << "飞机:tourism by Plane" << endl;//飞机方式出行
	}
	~Plane() {
		cout << "~Plane()" << endl;
	}
private:
	int price = 0;
};
void Fun(Pileup* p)//这里的形参必须是父类的引用或者指针，如果使用的是父类的对象，将会都是调用父类的虚函数
{
	p->fun();
}
int main()
{
	Pileup P;
	Fun(&P);//调用交通工具的类，因为是交通工具的对象
	Car c;
	Fun(&c);//调用汽车类，因为是汽车类的对象
	Plane PL;
	Fun(&PL);//调用飞机类，因为是飞机类的对象
	return 0;
}

形成多态的条件

必须通过基类的指针或者引用调用虚函数

多态的调用必须通过基类的指针或者引用进行调用，如果使用的是父类的对象，就不会有多态了，而是普通的调用，调用什么类型的对象，就调用它相对应的函数类型。多态是父类的指针或引用指向的对象，基类的对象调用基类的函数，派生类的对象就调用派生类的函数。

被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写（要有继承）

虚函数会在函数名前加上一个关键字virtual。而且派生类重写的时候，函数名相同，类型相同，参数的类型和个数要相同。
协变(基类与派生类虚函数返回值类型不同)：派生类重写基类虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指针或者引用，派生类虚函数返回派生类对象的指针或者引用时，称为协变。

重写虚函数

虚函数有关键字virtual，重写是在派生类中，派生类的虚函数函数名，类型，参数类型和个数要相同（派生类的虚函数可以不加关键字virtual）。重写即派生类重写实现基类虚函数的功能。


这里有一个Pileup类型的基类指针，指向了Car类型的派生类，通过解引用执行派生类Car的虚函数，但是x的值是0，说明派生类的虚函数是用基类虚函数的接口进入，参数的值只与基类的虚函数有关。

析构函数的重写

基类的析构函数必须要时虚函数，加上关键字virtual，如果析构函数不写成虚函数，一个基类的类型的指针指向一个派生类new的一个对象，如果释放的话，只会调用基类的析构函数，因为没有构成虚函数的重写。如果派生类有创建内存空间，不调用派生类的析构函数的话，可能会造成内存泄漏。

基类的析构函数必须要加上virtual成为虚函数。当基类的析构函数是虚函数的时候，指针是基类的类型，指向派生类的对象时，也可以调用到派生类的析构函数了。

多态的原理

在这里，这个基类的大小位8，是哪几个成员的，为什么是8，因为在Pileup这个类实例化的对象p中，有一个私有成员price和一个包含存虚函数地址的一个表，即虚表，虚表是一个指针，占4个字节，一个int类型的变量price也占4个字节（如果成员数量不同，可能会需要内存对齐）所以大小为8。成员函数fun1()是普通函数，是存放在代码区的，所以不占空间。两个虚函数把他们的地址存放在一个叫_vfptr（二级指针）的指针所指向的一个函数指针数组里。所以不管有多少虚函数，都只有一个_vfptr指针保存。指针_vfptr指向一个存着虚函数地址的表。只有虚函数才把地址存在这个虚函数表里，普通函数不存。所以虚函数也是存放在代码区的。

对象如何存储成员

基类Pileup对象p的存储数据

在基类Pileup实例化的对象p中，存储了两个变量，一个指针，一个int类型的成员变量，指针就是虚函数表的指针，通过内存的观察，我们可以发现表里有三个函数指针。

派生类Car对象c的存储数据

我们可以发现，这种单继承的类的每个对象都会有一个虚函数表，每个表的地址都不一样，如果基类的虚函数没有在派生类进行重写，派生类的虚表里存没有重写的虚函数地址跟基类的一样，如果重写了，就会是新的地址。

虚函数怎么执行

如果fun(int x)是虚函数，在编译的时候不会生成它的地址的指令，只有在执行的时候，会在虚函数表里找到它相对应的地址。再执行。这种也叫动态联编

如果fun(int x)不是虚函数，那么它就是普通函数的调用，当它完成编译的时候，就会生成相应的call指令，确定普通函数的地址。

虚函数调用什么样的对象，就调用相应类的虚函数

Car c是派生类的一个对象，当它调用Fun()的时候，把地址传过去，当用父类指针来接收的时候，会找到c对象中它继承下来的基类部分。派生类给基类的引用或指针赋值时，才能实现多态***（指针指向派生类中基类的那部分，引用把派生类中基类部分取别名，其实就是说虽然是基类的指针或引用，但是他们指向对象还是派生类实例化的对象基类部分或派生类实例化对象基类部分的别名------指针和引用类型的兼容），如果是派生类对象直接给基类对象赋值，基类对象的调用就是普通调用（因为派生类对象给基类对象赋值的时候，调用了拷贝构造，实例化的对象就是基类的对象了，就构成不了多态，但是不会把虚函数表的指针进行拷贝，直接再生成一个虚表指针，如果说可以拷贝，那虚表可能是派生类的，不是基类的，但是基类的对象不能调用派生类的虚函数）。***

在单继承中，如果对象的类型都一样，则生成的虚函数表指针都是一样的。

虚函数再哪个储存地方

虚函数和普通函数都是在代码区的，同时，虚函数表会把虚函数的地址保留起来，所以虚函数的指针在虚函数表。虚函数表存在常量区。

如何获得虚函数表的地址，通过之前的调试可以看出，虚表是存在对象的前4个字节，我们可以先把对象p1取地址，通过int类型的方式获取__vfptr的空间再解引用即可得到虚函数表的地址。任何一个虚函数都是会存在虚表里的。
class Pileup
{
public:
virtual void fun() {
cout << “交通工具:tourism” << endl;//出行
}
virtual void fun1()
{
cout << “fun1()Pileup” << endl;
}
virtual void fun2() {
cout << “fun2()Pileup” << endl;
}
//virtual ~Pileup() {
// //cout << “~Pileup()” << endl;
//}
private:
int price = 0;
};
class Car : public Pileup
{
public:
virtual void fun() {
cout << “汽车:tourism by car” << endl;//汽车方式出行
}
virtual void fun4()
{
cout << “fun4()Car” << endl;
}
virtual void fun3() {
cout << “fun3()Car” << endl;
}
//~Car() {
// //cout << “~Car()” << endl;
//}
private:
int price = 1;
};
class Plane : public Pileup
{
public:
virtual void fun() {
cout << “飞机:tourism by Plane” << endl;//飞机方式出行
}
~Plane() {
cout << “~Plane()” << endl;
}
private:
int price = 2;
};
class X : public Car
{
public:
virtual void fun3() {
cout << “fun3()X” << endl;
}
};
void Fun(Pileup p)
{
p->fun();
}
typedef void(VFUN)();
void PRINTFVFUN(VFUN a)
{
for (int i = 0; a[i] != 0; i++)
{
printf(“a[%d]:%p->”, i, a[i]);
VFUN f = a[i];
f();
}
printf(“\n”);
}
int main()
{
Pileup p;
Car c;
X x;
p.~Pileup();
PRINTFVFUN((VFUN)((int*)(&p)));//取对象p的地址，转化为int类型，获得前四个字节在解引用，得到虚表地址的值，然后在转化为函数指针的类型
PRINTFVFUN((VFUN)((int)(&c)));
PRINTFVFUN((VFUN*)((int)(&x)));
return 0;
}
Pileup有3个虚函数，Car继承了Pileup重写了fun，增加了fun3和fun4，X继承了Car重写了fun3。

多继承的多态

在多继承中，一个派生类继承了两个基类，会有两个虚表。

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;
};

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

如果派生类有自己独有的虚函数，则会把虚函数的地址放在第一个虚表。