《C++多态详解：从虚函数到运行时动态绑定》

《C++多态详解：从虚函数到运行时动态绑定》

---

---

一、多态的概念

---

二、多态的定义及实现

多态是一个继承关系下的类对象，去调用同一函数，产生了不同的行为。
比如Student继承了Person。Person对象买票全价，Student对象优惠买票

---

2.1 实现多态的两个必要条件

---

---

2.2 虚函数

类成员函数前面加virtual修饰，那么这个成员函数被称为虚函数。
注意：非成员函数不能加virtual修饰

---

2.3 虚函数的重写/覆盖

---

---

---

2.4 多态场景的一个选择题

本质重写的是基类的函数实现部分，函数声明部分编译认为子类和父类是一样的，
所以就默认使用父类
满足多态之后，用父类的声明部分+派生类重写的实现部分

---

---

2.5 虚函数重写的其他问题

2.5.1 协变

---

2.5.2 析构函数的重写

---

这里注意：析构函数加不加virtual都构成重写！

---

---

2.6 override和final关键字

---

2.7 重载/重写/隐藏的对比

共同点：

---

三、纯虚函数和抽象类

---

四、多态的原理

4.1 虚函数表指针

---

---

4.2 多态的原理

4.2.1 多态是如何实现

从底层的⻆度Func函数中ptr->BuyTicket()，是如何作为ptr指向Person对象调⽤Person::BuyTicket，ptr指向Student对象调⽤Student::BuyTicket的呢？

---

注意：ptr指向的始终存的都是Person对象
有可能本身就是Person对象，也有可能是切片出来的Person对象

---

4.2.2 动态绑定与静态绑定

静态绑定效率会高一些！

---

4.2.3 虚函数表

---

---

g++里虚函数表存在了 静态区！

---

五、整体源代码

代码如下（示例）：

// 多态！！！
//int main()
//{
//	int i;
//	double d;
//	cout << i;
//	cout << d;
//}
//
//swap(i1, i2);
//swap(d1, d2);//class Person {
//public:
//	virtual void BuyTicket() { cout << "买票-全价" << endl; }
//};
//class Student : public Person {
//public:
//	virtual void BuyTicket() { cout << "买票-打折" << endl; }
//};
//void Func(Person* ptr)
//{
//	// 这⾥可以看到虽然都是Person指针Ptr在调⽤BuyTicket
//	// 但是跟ptr没关系，⽽是由ptr指向的对象决定的。
//	ptr->BuyTicket();
//}
//int main()
//{
//	Person ps;
//	Student st;
//	Func(&ps);
//	Func(&st);
//	return 0;
//}//class Animal
//{
//public:
//	virtual void talk() const
//	{}
//};
//class Dog : public Animal
//{
//public:
//	virtual void talk() const
//	{
//		std::cout << "汪汪" << std::endl;
//	}
//};
//class Cat : public Animal
//{
//public:
//	virtual void talk() const
//	{
//		std::cout << "(>^ω^<)喵" << std::endl;
//	}
//};
//void letsHear(const Animal& animal)
//{
//	animal.talk();
//}
//int main()
//{
//	Cat cat;
//	Dog dog;
//	letsHear(cat);
//	letsHear(dog);
//	return 0;
//}//class A {};
//class B : public A {};
//class Person {
//public:
//	virtual A* BuyTicket()
//	{
//		cout << "买票-全价" << endl;
//		return nullptr;
//	}
//};
//class Student : public Person {
//public:
//	virtual B* BuyTicket()
//	{
//		cout << "买票-打折" << endl;
//		return nullptr;
//	}
//};
//void Func(Person* ptr)
//{
//	ptr->BuyTicket();
//}
//int main()
//{
//	Person ps;
//	Student st;
//	Func(&ps);
//	Func(&st);
//	return 0;
//}//class A
//{
//public:
//	virtual ~A()
//	{
//		cout << "~A()" << endl;
//	}
//};
//class B : public A {
//public:
//	~B()
//	{
//		cout << "~B()->delete:" << _p << endl;
//		delete _p;
//	}
//protected:
//	int* _p = new int[10];
//};
//// 只有派⽣类的析构函数重写了基类的析构函数，下⾯的delete对象调⽤析构函数，才能
//// 构成多态，才能保证p1和p2指向的对象正确的调⽤析构函数。
//int main()
//{
//	A* p1 = new A;
//	A* p2 = new B;
//	delete p1;
//	delete p2;
//	return 0;
//}// error C3668: “Benz::Drive”: 包含重写说明符“override”的⽅法没有重写任何基类⽅法
//class Car {
//public:
//	virtual void Dirve()
//	{}
//};
//class Benz :public Car {
//public:
//	virtual void Drive() override { cout << "Benz-舒适" << endl; }
//};
//int main()
//{
//	return 0;
//}// error C3248: “Car::Drive”: 声明为“final”的函数⽆法被“Benz::Drive”重写
//class Car
//{
//public:
//	virtual void Drive() final {}
//};
//class Benz :public Car
//{
//public:
//	virtual void Drive() { cout << "Benz-舒适" << endl; }
//};
//int main()
//{
//	return 0;
//}//class Car
//{
//public:
//	virtual void Drive() = 0;
//};
//class Benz :public Car
//{
//public:
//	virtual void Drive()
//	{
//		cout << "Benz-舒适" << endl;
//	}
//};
//class BMW :public Car
//{
//public:
//	virtual void Drive()
//	{
//		cout << "BMW-操控" << endl;
//	}
//};
//int main()
//{
//	// 编译报错：error C2259: “Car”: ⽆法实例化抽象类
//	// Car car;
//	Car* pBenz = new Benz;
//	pBenz->Drive();
//	Car* pBMW = new BMW;
//	pBMW->Drive();
//	return 0;
//}//class Person {
//public:
//	virtual void BuyTicket() { cout << "买票-全价" << endl; }
//private:
//	string _name;
//};
//class Student : public Person {
//public:
//	virtual void BuyTicket() { cout << "买票-打折" << endl; }
//private:
//	string _id;
//};
//class Soldier : public Person {
//public:
//	virtual void BuyTicket() { cout << "买票-优先" << endl; }
//private:
//	string _codename;
//};
//void Func(Person* ptr)
//{
//	// 这⾥可以看到虽然都是Person指针Ptr在调⽤BuyTicket
//	// 但是跟ptr没关系，⽽是由ptr指向的对象决定的。
//	ptr->BuyTicket();
//}
//int main()
//{
//	// 其次多态不仅仅发⽣在派⽣类对象之间，多个派⽣类继承基类，重写虚函数后
//	// 多态也会发⽣在多个派⽣类之间。
//	Person ps;
//	Student st;
//	Soldier sr;
//	Func(&ps);
//	Func(&st);
//	Func(&sr);
//}//// ptr是指针+BuyTicket是虚函数满⾜多态条件。
//// 这⾥就是动态绑定，编译在运⾏时到ptr指向对象的虚函数表中确定调⽤函数地址
//ptr->BuyTicket();
//00EF2001 mov eax, dword ptr[ptr]
//00EF2004 mov edx, dword ptr[eax]
//00EF2006 mov esi, esp
//00EF2008 mov ecx, dword ptr[ptr]
//00EF200B mov eax, dword ptr[edx]
//00EF200D call eax
//// BuyTicket不是虚函数，不满⾜多态条件。
//// 这⾥就是静态绑定，编译器直接确定调⽤函数地址
//ptr->BuyTicket();
//00EA2C91 mov ecx, dword ptr[ptr]
//00EA2C94 call Student::Student(0EA153Ch)//class Base {
//public:
//	virtual void func1() { cout << "Base::func1" << endl; }
//	virtual void func2() { cout << "Base::func2" << endl; }
//	void func5() { cout << "Base::func5" << endl; }
//protected:
//	int a = 1;
//};
//class Derive : public Base
//{
//public:
//	// 重写基类的func1
//	virtual void func1() { cout << "Derive::func1" << endl; }
//	virtual void func3() { cout << "Derive::func1" << endl; }
//	void func4() { cout << "Derive::func4" << endl; }
//protected:
//	int b = 2;
//};
//int main()
//{
//	Base b;
//	Derive d;
//	return 0;
//}//int main()
//{
//	int i = 0;
//	static int j = 1;
//	int* p1 = new int;
//	const char* p2 = "xxxxxxxx";
//	printf("栈:%p\n", &i);
//	printf("静态区:%p\n", &j);
//	printf("堆:%p\n", p1);
//	printf("常量区:%p\n", p2);
//	Base b;
//	Derive d;
//	Base* p3 = &b;
//	Derive* p4 = &d;
//	printf("Person虚表地址:%p\n", *(int*)p3);
//	printf("Student虚表地址:%p\n", *(int*)p4);
//	printf("虚函数地址:%p\n", &Base::func1);
//	printf("普通函数地址:%p\n", &Base::func5);
//	return 0;
//}

---