【C++】多态：编程中的“一人千面”艺术

目录

• 一、多态的概念
• 二、多态的定义及实现
• • 1.多态的构成条件
  • 2.虚函数的重写
  • • 2.1 什么是虚函数？
    • 2.2 虚函数的重写是什么？
    • 2.3 虚函数重写的两个例外
    • 2.4 C++11 override 和 final
    • 2.5 重载、覆盖(重写)、隐藏(重定义)的对比
    • 三、抽象类
    • • 3.1 概念
      • 3.2 接口继承和实现继承
      • 多态绝命题（超级坑）
      • 四、多态的原理
      • • 4.1虚函数表
        • 4.2多态的原理
        • • 4.2.1虚基表和虚表
          • 五、单继承和多继承关系的虚函数表
          • • 5.1 单继承中的虚函数表
            • 5.2 多继承中的虚函数表
            • 没有彩蛋有🥚

              前言

              本篇我们来探索一下C++中的多态，欢迎大家和我一起走进多态

              一、多态的概念

              概念：通俗说就是多种形态，不同的对象去完成同一件事情，会产生不同的结果(多种形态)

              例子：就拿买火车票来说，普通人和学生还有军人买票是不一样，普通人买票是全价，学生买票是半价，军人买票是优先买，他们都是人，但是买票的结果不一样，体现了不同的对象干同一件事结果不同

              二、多态的定义及实现

              1.多态的构成条件

              构成多态还有两个条件：

              ① 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写

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

              2.虚函数的重写

              2.1 什么是虚函数？

              虚函数：即被virtual修饰的类成员函数称为虚函数

              class Person
              {
              public:
              	//被virtual修饰的函数叫虚函数
              	virtual  void BuyTicke()
              	{
              		cout 
              public:
              	virtual void BuyTicket()
              	{
              		cout
              public:
              	//void BuyTicket()
              	virtual void BuyTicket()
              	{
              		cout
              	p.BuyTicket();
              }
              int main()
              {
              	Person p;
              	Student s;
              	func(p);
              	func(s);
              	return 0;
              }
              };
              class B :public A
              {};
              class Person
              {
              public:
              	virtual  A* BuyTicke()
              	{
              		cout 
              public:
              	virtual B* BuyTicke()
              	{
              		cout 
              public:
              	~Person() { cout 
              public:
              	~Student() 
              	{ 
              		cout 
              	Person* p1 = new Person;
              	Person* p2 = new Student;
              	delete p1;
              	delete p2;
              	return 0;
              }
              
              public:
              	//destructor()
              	virtual ~Person() { cout 
              public:
              	//destructor()
              	virtual ~Student() 
              	{ 
              		cout 
              public:
              	virtual void Drive() final {}
              };
              class Benz :public Car
              {
              public:
              	virtual void Drive() { cout 
              public:
              	virtual void Drive() {}
              };
              class Benz :public Car {
              public:
              	 virtual void Drive() override { cout 
              public:
              	virtual void Drive() = 0;//纯虚函数
              };
              
              public:
              	virtual void func(int val = 1) { std::cout  func(); }
              };
              class B : public A
              {
              public:
              	void func(int val = 0) { std::cout 
              	B* p = new B;
              	p-test();
              	return 0;
              }
              //A: A-0 B: B-1 C: A-1 D: B-0 E: 编译出错 F: 以上都不正确
              
              public:
              	virtual void Func1()
              	{
              		cout 
              	cout
              public:
              	virtual void BuyTicket() { cout 
              public:
              	virtual void BuyTicket() { cout 
              	p.BuyTicket();
              }
              int main()
              {
              	Person Mike;
              	Func(Mike);
              	Student Johnson;
              	Func(Johnson);
              	return 0;
              }
              
              public:
              	virtual void BuyTicket() { cout 
              public:
              	virtual void BuyTicket() { cout 
              	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);
              	Person p;
              	Student s;
              	Person* p3 = &p;
              	Student* p4 = &s;
              	printf("Person虚表地址:%p\n", *(int*)&p);
              	printf("Student虚表地址:%p\n", *(int*)&s);
              	return 0;
              }
              
              public:
              	virtual void Func1(){ cout  cout  cout 
              public:
              	virtual void Func1(){ cout  cout 
              	for (size_t i = 0; i