C++多态

多态

多态的概念

当去完成某个行为时，不同的对象调用，产生不同的行为。

构成多态的条件

• 必须通过基类（父类）指针或者引用调用虚函数。
• 被调用的函数必须是虚函数，派生类对基类的虚函数进行重写

满足多态：跟调用对象的类型无关，跟指向对象有关，指向哪个对象基于调用它的虚函数

不满足多态：跟调用它的类型有关，类型是什么就调用谁的虚函数。

#include<iostream>
using namespace std;

class A
{
public:
	void virtual BuyTicket()
	{
		cout << "购买全票" << endl;
	}
};

class B:public A
{
public:
	void virtual BuyTicket()
	{
		cout << "购买半票" << endl;
	}
};

void Fun(A& a)
{
	a.BuyTicket();
}

int main()
{
	A a;
	B b;
	Fun(a);
	Fun(b);
	return 0;
}

虚函数

虚函数：被virtual修饰的类非静态的成员函数称为虚函数。

class A
{
public:
	virtual void  BuyTicket()
	{
		cout << "购买全票" << endl;
	}
};

inline函数可以是虚函数吗？

内联函数可以是虚函数，但是如果将内联函数设置为虚函数将会丢失内联函数的属性，这个函数将不在是内联函数，因为虚函数是需要放到虚函数表的，内联函数没有地址，所有会丢失inline属性。

虚函数的重写

虚函数的重写（覆盖）：派生类中有一个和基类完全相同的虚函数（派生类与基类函数名 返回值 参数列表完全相同）称为子类的虚函数重写了基类的虚函数 ，重写是对函数体重写。

在重写基类虚函数时，派生类的虚函数在不加virtual关键字时，虽然也可以构成重写（因为继承后基类的虚函数被继承下来了在派生类依旧保持虚函数属性）但是这种写法不规范。

覆盖指的是将基类的虚表继承下来，然后如果派生类重新的了虚函数，那么就覆盖掉继承下来的对应虚表中的函数的地址。

class A
{
public:
	virtual void  BuyTicket()
	{
		cout << "购买全票" << endl;
	}
};

class B:public A
{
public:
	virtual void BuyTicket()
	{
		cout << "购买半票" << endl;
	}
};

虚函数重写的两个例外

协变（基类与派生类返回值类型不同）

派生类重写基类虚函数时，与基类的返回值类型不同，即基类虚函数返回基类对象的指针和引用，派生类虚函数返回派生类对象的指针和引用时，称为协变。·

class A
{
public:
	virtual A& BuyTicket()
	{
		cout << "成人票" << endl;
		return *this;
	}
};

class B :public A
{
public:
	virtual B& BuyTicket()
	{
		cout << "儿童票" << endl;
		return *this;
	}
};

void Fun(A& a)
{
	a.BuyTicket();
}

int main()
{
	A a;
	B b;
	Fun(a);
	Fun(b);
	return 0;
}

析构函数的重写（基类与派生类析构函数的名字不同）

如果基类的析构函数为虚函数，此时只要派生类定义析构函数，无论加不加virtual关键字，都与基类的构造函数构成重写，虽然基类的析构函数和派生类的析构函数，函数名不相同，看起来违背了重写的规则，其实，这里编译器对虚构函数的名字进行了特殊处理，编译后虚构函数的名字统一处理成了desturctor。

如果析构函数不定义为虚函数，那么在下面的程序中就会出现问题，当派生进行释放时，只是调用了基类的析构，可能会发生内存泄漏。

#include <iostream>
using namespace std;
class A
{
public:
	virtual ~A()
	{
		cout << "~A()" << endl;
	}

};

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

int main()
{
	A* a = new A;
	A* b = new B;
	delete a;
	delete b;
	return 0;
}

final关键字

final修饰虚函数，表示该虚函数不能再被重写。

#include<iostream>
using namespace std;

class A
{
public:
	//定义虚函数不能被重写
	virtual void Print() final
	{
		cout << "A" << endl;
	}
};

class B:public A
{
public:
	virtual void Print()
	{
		cout << "B" << endl;
	}
};

void fun(A& a)
{
	a.Print();
}
int main()
{
	A a;
	B b;
	fun(a);
	fun(b);
	return 0;
}

当final修饰的是类时，表示该类不能被继承。

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

};

关键字override

override检查派生类是否重写了基类某个虚函数，如果没有编译将会报错。

class A
{
public:
	virtual void Print()
	{
		cout << "A" << endl;
	}
};

class B :public A
{
public:
	//如果没有重写基类的Print函数 将会报错
	virtual void Print() override
	{
		cout << "B" << endl;
	}
};

抽象类

纯虚函数的定义: virtual 返回值类型 函数名 （参数列表）=0；

在虚函数的后面加上=0，则这个函数为纯虚函数。

包含纯虚函数的类称为抽象类（接口类），抽象类不能实例化出对象。派生类继承后也不能实例化出对象，只有重写纯虚函数，派生类才能实例化出对象。纯虚函数规范了派生类必须重写

class A
{
public:
	//纯虚函数
	virtual void Print() = 0;
};

class B :public A
{
public:
	virtual void Print()
	{
		cout << "B" << endl;
	}
};

多态的原理

虚函数表

虚函数表创建时机是在编译期间。编译期间编译器就为每个类确定好了对应的虚函数表里的内容。
所以在程序运行时，编译器会把虚函数表的首地址赋值给虚函数表指针，所以，这个虚函数表指针就有值了。

#include<iostream>
using namespace std;
class A
{
public:
	virtual void Fun()
	{
		cout << "Fun()" << endl;
	}

	int _a;
};

int main()
{
	A a;
	cout<<sizeof(a)<<endl;//8
	return 0;
}

在vs2017 32位平台下结果为8。

为什么为8呢，通过监视我们可以看到在变量a里面包含两个成员，一个为指向虚函数表指针，一个为变量_a;

一个含有虚函数的类中都至少都有一个虚函数表指针，因为虚函数的地址要放到虚函数表中，虚函数表也叫虚表。

#include<iostream>
using namespace std;
class A
{
public:
	virtual void Fun()
	{
		cout << "Fun()" << endl;
	}

	int _a;
};

class B :public A
{
public:
	virtual void Fun()
	{
		cout << "Fun()" << endl;
	}
	int _b;
};

int main()
{
	A a;
	B b;
	return 0;
}

通过观察我们可以看到

• 派生类对象b也含有一个虚函数表指针，b对象由两部分组成，一部分是父类继承下来的成员，一部分是自己的成员。
• 基类的a和派生类的b，虚函数表是不一样的，Fun完成了重写，所以对象b的虚函数表中存的是B::Fun(),所以虚函数的重写也叫覆盖。
• 虚表存的是虚函数的指针，不是虚函数，对象中存的是虚表指针。

多态的原理

蓝色箭头可以看到，p指向a对象时，p.BuyTicket()函数在a虚基表中找到的虚函数是Person::BuyTickrt。

红色箭头可以看到，P指向b对象时，P.BuyTicket（）函数在b的虚基表中找到的虚函数是Student::BuyTickrt。

满足多态以后的函数调用，不是在函数编译时确定的，而是在运行以后在对象的虚函数表中去找的，不满足多态的函数调用是编译时确定好的。

虚函数表存在的位置

虚函数表存在代码段中。

证明：

#include<iostream>
using namespace std;

class A
{
public:
	virtual void Print()
	{
		cout << "class A Print" << endl;
	}
	int _a = 1;

};
void text1()
{
	A a1;
}

void text2()
{
	A a2;
}

int main()
{
	text1();
	text2();
	return 0;
}

我们通过测试我么可以看到，a1和a2为同类型，在a1销毁后创建a2，其中a1和a2中的虚函数表指针却是相同的，所以虚函数表肯定不会存在栈中。

#include<iostream>
using namespace std;

class A
{
public:
	virtual void Print()
	{
		cout << "class A Print" << endl;
	}
	int _a = 1;

};
void text1()
{
	A a1;
}

void text2()
{
	A a2;
}

void Fun()
{
	int* p1 = new int;
	const char* p2 = "hello";//常量字符串
	A a;
	printf("虚函数表地址%p\n", *(int*)&a);
	printf("栈变量地址%p\n", &a);
	printf("堆变量地址%p\n", p1);
	printf("代码段常量地址%p\n", p2);
	printf("虚函数地址%p\n", &A::Print);
	printf("普通函数地址%p\n", text1);
}
int main()
{
	//text1();
	//text2();

	Fun();
	return 0;
}

虚函数表（虚表）的打印

单继承

如果一个类中有虚函数，那么编译器会为这个类生成一个虚函数表（用于存放虚函数的地址），而虚函数表并不存在类中，而类中存储的是虚函数表的指针，称为虚表指针。在32位机下，对象的前4个字节为虚函数表的地址。

//单继承
#include<iostream>
using namespace std;

class A
{
public:
	virtual void fun1()
	{
		cout << "fun1()" << endl;
	}
	virtual void fun2()
	{
		cout << "fun2()" << endl;
	}
};

class B :public A
{
public:
	virtual void fun2()
	{
		cout << "class b fun2(）" << endl;
	}

	virtual void fun3()
	{
		cout << "class b fun3()" << endl;
	}
	virtual void fun4()
	{
		cout << "class b fun4()" << endl;
	}
};
typedef void(*VFTable)();

void Print(VFTable* p)
{
	for (int i = 0; p[i] != NULL; i++)
	{
		printf("p[%d]%p->", i, p[i]);
		VFTable tmp = p[i];
		tmp();
	}
}
void fun()
{
	A a;
	B b;
	printf("A\n");
	Print((VFTable*)*(int*)&a);
	printf("B\n");
	Print((VFTable*)*(int*)&b);
}

int main()
{
	fun();
	return 0;
}

多继承中的虚函数表

#include<iostream>
using namespace std;

class A
{
public:
	virtual void fun1()
	{
		cout << "class A fun1()" << endl;
	}
};

class B
{
public:
	virtual void fun2()
	{
		cout << "class B fun2()" << endl;
	}
};

class C :public A, public B
{
public:
	virtual void fun3()
	{
		cout << "class C fun3()" << endl;
	}
	virtual void fun4()
	{
		cout << "class C fun4()" << endl;
	}
};


typedef void(*VF)();

void PrintVFTable(VF* p)
{
	for (int i = 0; p[i] != NULL; i++)
	{
		printf("p[%d]:%p", i, p[i]);
		VF tmp = p[i];
		tmp();
	}
}

void text1()
{
	class C c;
	//class A a;
	//PrintVFTable((VF*)*(int*)&a);
	printf("A\n");
	PrintVFTable((VF*)*(int*)&c);
	printf("B\n");
	PrintVFTable((VF*)*(int*)((char*)&c + sizeof(A)));
}
int main()
{
	text1();
	return 0;
}

多继承派生类未重写的虚函数放在第一个基类继承的虚表中。