从C语言到C++_23(多态)抽象类+虚函数表VTBL+多态的面试题(上)

简介: 从C语言到C++_23(多态)抽象类+虚函数表VTBL+多态的面试题

1. 多态(polymorphism)

多态,就是 "多种形态" 的意思。

说具体点就是:去完成某个行为,不同的对象去做会产生不同的结果(状态)。

比如说地铁站买票这个行为,普通人、学生、军人买票是不同的。

普通人必须买全价票,学生就可能可以买半价票,而军人可以优先购买到预留票:

比如有一个 BuyTicket 买票的成员函数,创建普通人、学生和军人三个对象,

他们调用该函数形态结果我们就要设计成不一样的。

这种”不一样“的情况还有各种VIP等等。

所以由此可见,我们需要一种特性来做到这种 "分类" 的操作,这时我们就可以将其实现成多态。

1.1 构成多态的两个条件

构成多态的两个条件:

1、虚函数重写(覆盖) ->  虚函数 + 三同:函数名、参数和返回值相同,不符合重写就是隐藏。

2、父类指针或者引用去调用虚函数

特例1:子类虚函数不加virtual,依旧构成重写 (实际最好加上)

特例2:重写的协变。返回值可以不同,要求必须是父子关系的的指针或者引用

1.2 虚函数重写(覆盖)

我们先用代码实现一下我们刚才的购票场景。将 Student 和 Soldier 继承自 Person:

class Person {};
class Student : public Person {};
class Soldier : public Person {};

这里用 virtual 虚函数,并且做到函数名、参数和返回值相同,就能够达到 "重写" 的效果:

(不符合重写,就是隐藏关系)

class Person 
{
public:
    virtual void BuyTicket() // virtual + 返回值 + 函数名+ 参数 相同 = 构成多态
    {
        cout << "Person: 买票-全价" << endl;
    }
};
 
class Student : public Person 
{
public:
    // 这里也都相同
    virtual void BuyTicket() 
    {
        cout << "Student: 买票-半价" << endl;
    }
};
 
class Soldier : public Person 
{
public:
    // 这里也都相同
    virtual void BuyTicket() 
    {
        cout << "Soldier: 优先买票" << endl;
    }
};

概念:重写也称为覆盖,重写即重新改写。

重写是为了将一个已有的事物进行某些改变以适应新的要求。

重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。

最后我们再设计一个 Pay 函数去接收不同的身份,以调用对应的 BuyTicket 函数。

这里我们可以用指针和引用,这里我们用引用:

#include <iostream>
using namespace std;
 
class Person 
{
public:
    virtual void BuyTicket() // virtual + 返回值 + 函数名+ 参数 相同 = 构成多态
    {
        cout << "Person:  买票-全价" << endl;
    }
};
 
class Student : public Person 
{
public:
    // 这里也都相同
    virtual void BuyTicket() 
    {
        cout << "Student: 买票-半价" << endl;
    }
};
 
class Soldier : public Person 
{
public:
    // 这里也都相同
    virtual void BuyTicket() 
    {
        cout << "Soldier: 优先买票" << endl;
    }
};
 
void Pay(Person& p)
{
  p.BuyTicket();
}
 
int main()
{
  Person ps;
  Student st;
  Soldier sd;
 
  Pay(ps);
  Pay(st);
  Pay(sd);
  
  return 0;
}

再看多态两个条件:

1、虚函数重写(覆盖)

2、父类指针或者引用去调用虚函数

特例1:子类虚函数不加virtual,依旧构成重写 (实际最好加上)

特例2:重写的协变。返回值可以不同,要求必须是父子关系的的指针或者引用

这里我们就构成了多态。(如果把Pay函数的引用去掉就不是多态了,调的三个都是全价)

1.3 协变构成多态

协变(基类与派生类虚函数返回值类型不同)

派生类重写基类虚函数时,与基类虚函数返回值类型不同。

即基类虚函数返回基类对象的指针或者引用,

派生类虚函数返回派生类对象的指针或者引用时,称为协变。(了解)

观察下面的代码,并没有达到 "三同" 的标准,它的返回值是不同的,但依旧构成多态:

#include <iostream>
using namespace std;
class A {};
class B : public A {};
 
class Person 
{
public:
  virtual A* f() 
  {
    cout << "virtual A* Person::f()" << endl;
    return nullptr;
  }
};
 
class Student : public Person 
{
public:
  virtual B* f() 
  {
    cout << "virtual B* Student::f()" << endl;
    return nullptr;
  };
};
 
int main()
{
  Person p;
  Student s;
  Person* ptr = &p;
  ptr->f();
 
  ptr = &s;
  ptr->f();
 
  return 0;
}

但是协变也是有条件的,协变的类型必须是父子关系。

1.4 父虚子非虚构成多态

子类的虚函数没了却能构成多态:

#include <iostream>
using namespace std;
class A {};
class B : public A {};
 
class Person
{
public:
  virtual A* f()
  {
    cout << "virtual A* Person::f()" << endl;
    return nullptr;
  }
};
 
class Student : public Person
{
public:
  B* f() 
  {
    cout << "virtual B* Student:::f()" << endl;
    return nullptr;
  };
};
 
int main()
{
  Person p;
  Student s;
  Person* ptr = &p;
  ptr->f();
 
  ptr = &s;
  ptr->f();
 
  return 0;
}

这都不是虚函数了怎么也能构成多态呢?

解答:子类虚函数没有写 virtual,但 f 依旧是虚函数,是因为先继承了父类的函数接口声明。

子类继承父类的虚函数是一种接口继承,所以即使子类的 virtual 没写,它也是虚函数,

符合多态条件。这是重写父类虚函数的实现,也就是说父类有 virtual 的属性,子类也就有了。

最后,虽然子类虚函数可以不加 virtual,但是我们自己写的时候 子类虚函数建议加上 virtual。

总结:父类为虚函数,子类继承其父的情况下,即使不声明 virtual 也能构成多态。

1.5 析构函数的重写

如果基类的析构函数为虚函数,此时派生类析构函数只要定义,无论是否加virtual关键字,

都与基类的析构函数构成重写,虽然基类与派生类析构函数名字不同。虽然函数名不相同,

看起来违背了重写的规则,其实不然,这里可以理解为编译器对析构函数的名称做了特殊处

理,编译后析构函数的名称统一处理成destructor。

#include <iostream>
using namespace std;
 
class Person
{
public:
  ~Person() 
  {
    cout << "~Person()" << endl;
  }
};
 
class Student : public Person 
{
public:
  ~Student() 
  {
    cout << "~Student()" << endl;
  }
};
 
int main()
{
  Person p;
  Student s;
 
  return 0;
}

dd51fb691b18406499210fb6b264a059.png

第一行和第二行是 Student s 的,第三行是 Person p 的。我们来看看析构顺序,


Student s 是后定义的,析构顺序是后定义先析构。根据子类对象析构先子后父,


调用子类的析构函数结束后自动调用父类的析构函数,


所以第一行的 ~Student() 和第二行的 ~Person() 都是 Student 的,


随后第三行的 ~Person() 是 Person p 自己调的。


现在这两个析构函数默认是隐藏关系,


因为它们的函数名会被同一处理修改成 destructor 。


但是如果用 virtual 修饰 ~Person,我们知道,如果这加了不管 ~Student 加不加 virtual,


子类都会跟着父类变身成 virtual,那么现在这两个析构函数还是隐藏关系吗?


如果 Person 的析构函数加了 virtual,隐藏关系就变成了重写关系。


对普通对象(像上面的代码)来说,这里加 virtual 并不会带来什么改变,

再看另一段代码:

#include <iostream>
using namespace std;
 
class Person 
{
public:
  virtual ~Person() 
  {
    cout << "~Person()" << endl;
  }
};
 
class Student : public Person 
{
public:
  ~Student() // 隐藏(重定义)关系 -> 重写(覆盖) 关系
  {
    cout << "~Student()" << endl;
  }
};
 
int main()
{
  Person* ptr1 = new Person; // delete 调用 Person 的析构,对这个也没有影响
  delete ptr1;
 
  Person* ptr2 = new Student; // 但是对这样的场景会产生影响
  delete ptr2;
 
  return 0;
}

把父类的virtual 去掉:

刚才我们看到了,如果这里不加 virtual,~Student 是没有调用析构的。

你可能会想这有啥,那是因为这里没场景,这其实是非常致命的,是不经意间会发生的内存泄露。

比如下面这个场景,我们是希望 delete 谁调用的就是谁的析构:

#include <iostream>
using namespace std;
 
class Person
{
public:
  ~Person() 
  {
    cout << "~Person()" << endl;
  }
};
 
class Student : public Person
{
public:
  ~Student() // 隐藏(重定义)关系 -> 重写(覆盖) 关系
  {
    cout << "~Student()" << endl;
    delete[] _name;
    cout << "delete: " << (void*)_name << endl;
  }
 
private:
  char* _name = new char[10] { 'h', 'e', 'l', 'l', 'o' };
};
 
int main()
{
  // 我们期望 delete ptr 调用析构函数是一个多态调用
  Person* ptr = new Person;
  delete ptr;   // ptr->destructor() + operator delete(ptr)
 
  ptr = new Student;
  delete ptr;   // ptr->destructor() + operator delete(ptr)
 
  return 0;
}

但是结果让我们很失望,Student 没析构。我们加上 virtual 再试试:

结论:如果设计的类可能会作为父类,析构函数最好设计成虚函数,即加上 virtual。

像刚才这种场景不加上 virtual 就会发生内存泄露,可怕的是还是悄无声息的!

报错不可怕,怕的是这种悄无声息的,像这种内存泄露找起来可是相当的恶心。

1.6 final 和 override 关键字(C++11)

final 关键字(C++11)

上一篇提到:C++11提供了关键字 final 写在类的后面,表明这个类不能被继承。

如果我有个虚函数,但我不想让它被人重写:

也可以关键字 final 写在函数的后面让虚函数不能被重写

#include <iostream>
using namespace std;
 
class Car 
{
public:
  virtual void Drive() final 
  {}
};
 
class Benz : public Car 
{
public:
  virtual void Drive() // 错误  C3248 "Car::Drive": 声明为 "final" 的函数不能由 "Benz::Drive" 重写
  {
    cout << "Benz" << endl;
  }
};
 
int main()
{
  return 0;
}

总结:final 的两个作用

写在虚函数后面让虚函数不能被重写

写在类后面让类不能被继承


override 关键字(C++11)

相信大家也体会到了 C++ 对函数重写的要求是非常严格的,


但是人难免会犯错,有些时候可能会导致函数名次序写反而无法构成重载,


而这种错误在编译期间是不会报的,因此往往只有在程序运行时你发现没有得到预期结果,


去 debug 找个半天才能将问题找出,这会让人感到非常的不爽:C++11 为了增加容错率,

推出了 final 和 override,find 是禁止重写,override 是必须重写。

override 关键字可以帮助你检查重写:

#include <iostream>
using namespace std;
 
class Car 
{
public:
  virtual void Drive() {}
};
 
// override 写在子类中:要求严格检查是否完成重写,如果没有重写就报错
class Benz : public Car 
{
public:
  virtual void Drive() override 
  {
    cout << "Benz" << endl;
  }
};
 
int main()
{
  return 0;
}

把父类 virtual 去掉就报错:

#include <iostream>
using namespace std;
 
class Car 
{
public:
  void Drive() {}
};
 
// override 写在子类中:要求严格检查是否完成重写,如果没有重写就报错
class Benz : public Car 
{
public:
  virtual void Drive() override//错误 C3668 “Benz::Drive”: 包含重写说明符“override”的方法没有重写任何基类方法
  {
    cout << "Benz" << endl;
  }
};
 
int main()
{
  return 0;
}

有了 override 修饰,像如果没有加 virtual 或参数不同就会报错。

当然,子类是可以省略 virtual 的,override 不会犯病报错放心使用,其在某些场景是非常有用的。

总结:override 写在子类中,会严格检查是否完成重写,如果没有就会报错提醒。

1.7 重载、覆盖、隐藏的对比

2. 抽象类(Abstract Class)

抽象在现实一般没有具体对应的实体,而不能实例化对象也就是没有实体,所以叫抽象类。

"抽象即不可名状,对应的是具象,具象即现实,抽象即虚拟。"

2.1 纯虚函数和抽象类

在虚函数的后面写上 =0,则我们称这个函数为 "纯虚函数"。

包含纯虚函数的类,就是 抽象类(abstract class),也叫接口类。

抽象类不能实例化出对象,子类即使在继承后也不能实例化出对象,只有重写纯虚函数,

子类才能实例化出对象。纯虚函数规范了派生类必须重写,另外纯虚函数更体现出了接口继承

#include <iostream>
using namespace std;
 
class Car 
{
public:
  virtual void Drive() = 0;
};
 
class BMW : public Car // 如果父类是抽象类,子类必须重写才能实例化
{
public:
  virtual void Drive() // 重写 注释掉就会报错:错误 C2259 “BMW” : 无法实例化抽象类
  {
    cout << "BMW" << endl;
  }
};
 
int main()
{
  BMW b;
  b.Drive();
 
  return 0;
}

如果 override 是直接要求你重写,那设计成抽象类就是间接要求你重写。

override 是放在子类虚函数,检查重写,它们的功能其实是有一些重叠和相似的。

纯虚函数规范了子类必须重写,另外虚函数更体现出了接口继承。

总结:抽象类不能实例化出对象,子类即使在继承后也不能实例化出对象,除非子类重写。

2.2 抽象类指针

虽然父类是抽象类不能定义对象,但是可以定义指针。

定义指针时如果 new 父类对象因为是纯虚函数,自然是 new 不出来的,

但是可以 new 子类对象:

#include <iostream>
using namespace std;
 
class Car
 {
public:
  virtual void Drive() = 0;
};
 
class BMW : public Car 
{
public:
  virtual void Drive() 
  {
    cout << "BMW" << endl;
  }
};
 
int main()
{
  Car* BMW1 = new BMW;
  BMW1->Drive();
 
  BMW* BMW2 = new BMW;
  BMW2->Drive();
 
  return 0;
}


从C语言到C++_23(多态)抽象类+虚函数表VTBL+多态的面试题(中);https://developer.aliyun.com/article/1521916

目录
相关文章
|
22小时前
|
存储 编译器 C++
【C++】深度解剖多态(下)
【C++】深度解剖多态(下)
8 1
【C++】深度解剖多态(下)
|
9天前
|
存储 编译器 C++
|
22小时前
|
Java 编译器 C++
【C++】深度解剖多态(上)
【C++】深度解剖多态(上)
13 2
|
2天前
|
Java
Java面试题:什么是多态以及在Java中如何实现?请详细解释说明
Java面试题:什么是多态以及在Java中如何实现?请详细解释说明
7 0
|
7天前
|
编译器 程序员 C++
【C++高阶】掌握C++多态:探索代码的动态之美
【C++高阶】掌握C++多态:探索代码的动态之美
13 0
|
9天前
|
存储 编译器 C++
C++基础知识(七:多态)
多态是面向对象编程的四大基本原则之一,它让程序能够以统一的接口处理不同的对象类型,从而实现了接口与实现分离,提高了代码的灵活性和复用性。多态主要体现在两个层面:静态多态(编译时多态,如函数重载)和动态多态(运行时多态,主要通过虚函数实现)。
|
7天前
|
存储 算法 Java
Java面试之SpringCloud篇
Java面试之SpringCloud篇
27 1
|
7天前
|
缓存 NoSQL Redis
Java面试之redis篇
Java面试之redis篇
22 0
|
7天前
|
SQL 关系型数据库 MySQL
java面试之MySQL数据库篇
java面试之MySQL数据库篇
14 0
java面试之MySQL数据库篇
|
7天前
|
存储 缓存 前端开发
Java八股文面试之多线程篇
Java八股文面试之多线程篇
19 0
Java八股文面试之多线程篇