【C++】多态-阿里云开发者社区

一、多态的定义及实现

1、概念

多态的概念：通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。

一个具体的例子就是买票这个行为：当普通人买票时，是全价买票；学生买票时，是半价买票；军人买票时是优先买票。

2、多态的实现

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

在继承中要构成多态还有两个条件：

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

//基类
class Person
{
public:
  virtual void BuyTicket()
  {
    cout << "票价——全价" << endl;
  }
};
//派生类
class Student : public Person
{
public:
  virtual void BuyTicket()
  {
    cout << "票价——半价" << endl;
  }
};
//引用构成多态
void func(Person& p)
{
  p.BuyTicket();
}
int main()
{
  Person* pp1 = new Person;
  Person* pp2 = new Student;
  //如果不构成多态，就按指针的类型去调用对应的函数，如果构成多态就按指针指向的对象去调用对应的函数
  pp1->BuyTicket();
  pp2->BuyTicket();
  Person p1;
  Student s1;
  func(p1);
  func(s1);
}

3、虚函数

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

//虚函数
virtual void BuyTicket()
{
  cout << "票价——全价" << endl;
}

虚函数的重写

虚函数的重写(覆盖)：派生类中有一个跟基类完全相同的虚函数(即派生类虚函数与基类虚函数的返回值类型、函数名字、参数列表完全相同)，称子类的虚函数重写了基类的虚函数。

//基类
class Person
{
public:
  virtual void BuyTicket()
  {
    cout << "票价——全价" << endl;
  }
};
//派生类
class Student : public Person
{
public:
  //虚函数的重写 (子类可以不加virtual关键字)
  virtual void BuyTicket()
  {
    cout << "票价——半价" << endl;
  }
};

注意：在重写基类虚函数时，派生类的虚函数在不加virtual关键字时，虽然也可以构成重写(因为继承后基类的虚函数被继承下来了在派生类依旧保持虚函数属性）,但是该种写法不是很规范，不建议这样使用。

虚函数重写的两个例外：

协变(基类与派生类虚函数返回值类型不同)
派生类重写基类虚函数时，与基类虚函数返回值类型不同。虽然不同但也是有要求的，即基类虚函数返回基类对象的指针或者引用，派生类虚函数返回派生类对象的指针或者引用时，称为协变

//基类
class A
{};
//派生类
class B : public A
{};
//基类
class Person
{
public:
  //基类虚函数返回基类对象的指针或者引用
  //virtual Person* BuyTicket()
  virtual A* BuyTicket()
  {
    cout << "票价——全价" << endl;
    return nullptr;
  }
};
//派生类
class Student : public Person
{
public:
  //派生类虚函数返回派生类对象的指针或者引用
  //virtual Student* BuyTicket()
  virtual B* BuyTicket()
  {
    cout << "票价——半价" << endl;
    return nullptr;
  }
};

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

//析构函数的重写
//基类
class Person
{
public:
  virtual ~Person()
  {
    cout << "~Person()" << endl;
  }
};
//派生类
class Student : public Person
{
public:
  virtual ~Student()
  {
    cout << "~Student()" << endl;
  }
};

C++11 override 和 final

C++对函数重写的要求比较严格，但是有些情况下由于疏忽，可能会导致函数名字母次序写反而无法构成重载，而这种错误在编译期间是不会报出的，只有在程序运行时没有得到预期结果才来debug会得不偿失，因此：C++11提供了override和final两个关键字，可以帮助用户检测是否重写。

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

class Car
{
public:
  virtual void Drive() final {}
};
class Benz : public Car
{
public:
  //编译报错，Drive()不能被重写
  virtual void Drive() {cout << "Benz" << endl;}
};

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

class Car{
public:
  virtual void Drive(){}
};
class Benz :public Car {
public:
  virtual void Drive() override {cout << "Benz" << endl;}
};

总结：final加在父类虚函数的后面，override加在子类的虚函数后面。

重载、覆盖(重写)、隐藏(重定义)的对比

抽象类

在虚函数的后面写上 =0 ，则这个函数为纯虚函数。包含纯虚函数的类叫做抽象类（也叫接口类），抽象类不能实例化出对象。派生类继承后也不能实例化出对象，只有重写纯虚函数，派生类才能实例化出对象。纯虚函数规范了派生类必须重写，另外纯虚函数更体现出了接口继承。

//抽象类
class Car
{
public:
  //纯虚函数
  virtual void Drive() = 0;
};
class Benz :public Car
{
public:
  //重写纯虚函数
  virtual void Drive()
  {
    cout << "Benz" << endl;
  }
};
int main()
{
  Car* pBenz = new Benz;
  pBenz->Drive();
}

接口继承和实现继承

普通函数的继承是一种实现继承，派生类继承了基类函数，可以使用函数，继承的是函数的实现。虚函数的继承是一种接口继承，派生类继承的是基类虚函数的接口，目的是为了重写，达成多态，继承的是接口。所以如果不实现多态，不要把函数定义成虚函数。

看下面的程序输出的结果是什么

class A
{
public:
  virtual void func(int val = 1){ std::cout<<"A->"<< val <<std::endl;}
  void test(){ func();}
};
class B : public A
{
public:
  void func(int val=0){ std::cout<<"B->"<< val <<std::endl; }
};
int main(int argc ,char* argv[])
{
  B*p = new B;
  p->test();
  return 0;
}

父类与子类的两个func函数构成多态，由于虚函数是接口继承所以，缺省值也应该是父类的缺省值，故答案是B->1。

二、多态的原理

1、虚函数表

我们先来看下面一段代码在x86平台下输出的结果是什么？

class Base
{
public:
virtual void Func1()
{
cout << "Func1()" << endl;
}
private:
int _b = 1;
};
int main()
{
  Base b1;
  cout<< sizeof(Base) <<endl;
  return 0;
}

答案是：

你可能会很好奇，为什么这里是8呢？原因是，含有虚函数类的对象都会有一个虚函数指针，这个指针指向了虚函数表，虚函数表里面存放的是虚函数的地址。

我们看下面的代码进一步分析这里的虚函数表

// 增加一个派生类Derive去继承Base
// Derive中重写Func1
// Base再增加一个虚函数Func2和一个普通函数Func3
class Base
{
public:
  virtual void Func1()
  {
    cout << "Base::Func1()" << endl;
  }
  virtual void Func2()
  {
    cout << "Base::Func2()" << endl;
  }
  void Func3()
  {
    cout << "Base::Func3()" << endl;
  }
private:
  int _b = 1;
};
class Derive : public Base
{
public:
  virtual void Func1()
  {
    cout << "Derive::Func1()" << endl;
  }
private:
  int _d = 2;
};
int main()
{
  Base b;
  Derive d;
  return 0;
}

我们打开监视窗口，进行进一步观察：

派生类对象d中也有一个虚表指针，d对象由两部分构成，一部分是父类继承下来的成员，一部分是自己的成员。
基类b对象和派生类d对象虚表是不一样的，这里我们发现派生类中Func1完成了重写，所以d的虚表中存的是重写的Derive::Func1，所以虚函数的重写也叫作覆盖，覆盖就是指虚表中虚函数的覆盖。重写是语法的叫法，覆盖是原理层的叫法。
另外Func2继承下来后是虚函数，所以放进了虚表，Func3也继承下来了，但是不是虚函数，所以不会放进虚表。
虚函数表本质是一个存虚函数指针的指针数组，一般情况这个数组最后面放了一个nullptr（vs系列的编译器下是nullptr，g++下没有）。
派生类的虚表生成：

先将基类中的虚表内容拷贝一份到派生类虚表中(注意是拷贝，派生类的虚表与基类的虚表并不是同一份虚表，所以派生类重写虚函数不会影响基类的虚表)
如果派生类重写了基类中某个虚函数，用派生类自己的虚函数覆盖虚表中基类的虚函数
派生类自己新增加的虚函数按其在派生类中的声明次序增加到派生类虚表的最后。

虚函数存在哪的？虚表存在哪的？
虚表存的是虚函数指针，不是虚函数，虚函数和普通函数一样的，都是存在代码段的，只是他的指针又存到了虚表中。另外对象中存的不是虚表，存的是虚表指针。那么虚表存在哪的呢？实际我们去验证一下会发现vs下是存在代码段的。

2、多态的原理

1、不构成多态时

在调用含有虚函数的类的成员函数时，编译器会先去判定其构不构成多态，如果不构成多态，就直接按指针或引用的类型去调用对应类的成员函数。

2、构成多态时

如果构成多态编译器就会按照下面的步骤去调用函数：

取对象中的虚函数表指针，找到虚函数表
在虚函数表中找到要调用的虚函数，进行调用。

这样就实现出了不同对象去完成同一行为时，展现出不同的形态。

反过来思考我们要达到多态，有两个条件，一个是虚函数覆盖，一个是对象的指针或引用调用虚函数，这两个条件缺一不可，如果虚函数不进行重写，那么派生类中的虚表存放的虚函数的地址还是基类的虚函数的地址，无法实现多态，如果不是指针和引用，就无法拿到派生类的虚函数表指针。(子类拷贝赋值给父类对象时，不会进行虚函数表指针的拷贝！！！)

可以看出满足多态以后的函数调用，不是在编译时确定的，是运行
起来以后到对象的中取找的。不满足多态的函数调用时编译时确认好的。

3、动态绑定与静态绑定

静态绑定又称为前期绑定(早绑定)，在程序编译期间确定了程序的行为，也称为静态多态，比如：函数重载
动态绑定又称后期绑定(晚绑定)，是在程序运行期间，根据具体拿到的类型确定程序的具体行为，调用具体的函数，也称为动态多态。

三、单继承和多继承关系的虚函数表

在前面我们都是重点讨论了基类的虚函数表，下面我们来探讨一下，派生类对象的虚表模型。

1、单继承中的虚函数表

我们看下面一段代码，并打开监视窗口：

class Base
{
public:
  virtual void func1() { cout << "Base::func1" << endl; }
  virtual void func2() { cout << "Base::func2" << endl; }
private:
  int a;
};
class Derive :public Base
{
public:
  //重写了基类中存在的虚函数
  virtual void func1() { cout << "Derive::func1" << endl; }
  //新增了两个基类中不存在的虚函数
  virtual void func3() { cout << "Derive::func3" << endl; }
  virtual void func4() { cout << "Derive::func4" << endl; }
private:
  int b;
};
int main()
{
  Base b;
  Derive d;
  return 0;
}

观察下图中的监视窗口中我们发现看不见func3和func4。这里是vs的编译器的监视窗口故意隐藏了派生类的新增的虚函数。

我们可以使用代码打印出虚表中的函数地址，看一看派生类新增的虚函数在不在继承下来的基类的对象的虚函数表里面。

//typedef一下函数指针
typedef void(*VF_PTR)();
//打印虚表
void PrintVFT(VF_PTR table[])//参数是一个函数指针数组
{
  //vs下虚表的最后一个是nullptr
  for (int i = 0; table[i] != nullptr; ++i)
  {
    //打印一下虚表
    printf("table[%d] : %p ->", i, table[i]);
    //调用一下虚表中的函数
    VF_PTR f = table[i];
    f();
  }
  printf("\n");
}
int main()
{
  Base b;
  Derive d;
  //vs下虚函数表指针就在对象的头部
  //取b的地址转化为(int*)然后进行解引用拿到前4个字节(x64下应该取前8个字节)，
  //然后将这4个字节的数据转换为VF_PTR*类型,与函数调用的参数进行匹配。
  PrintVFT((VF_PTR*)(*(int*)&b));
  PrintVFT((VF_PTR*)(*(int*)&d));
  return 0;
}

我们运行代码，可以看到结果：

结论：派生类新增的虚函数在继承下来的基类的对象的虚函数表里面！只是vs的监视窗口没有显示。

2、多继承中的虚函数表

我们看下面一段代码来研究多继承中的虚函数表

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:
  //重写func1()
  virtual void func1() { cout << "Derive::func1" << endl; }
  //新增fun3()
  virtual void func3() { cout << "Derive::func3" << endl; }
private:
  int d1;
};
int main()
{
  Derive d;
  PrintVFT((VF_PTR*)(*(int*)&d));
  //PrintVFT((VF_PTR*)(*(int*)((char*)&d + sizeof(Base1))));
  Base2* pb2 = &d;
  //注意这里的指针的指向要正确
  PrintVFT((VF_PTR*)(*(int*)pb2));
  return 0;
}

结果：

可以知道我们多继承以后，Derive对象里面有两张虚函数表，分别继承与Base1与Base2,但是我们新增的func3()虚函数放在了第一张虚函数表里面了。

我们再进行仔细观察会发现我们在Derive类中重写了func1，重写完之后的func1即会覆盖Base1的虚函数表也会覆盖Base2的虚函数表，但是两张虚函数表里面func1的地址在两张虚表中并不相同，这里很奇怪，明明是同一个函数为什么在两张虚表中的地址却不一样呢？

下面我们来讨论这个问题。

对上面的三个类我们运行下面的代码，去看一看它们的汇编代码：

int main()
{
  Derive d;
  //打印虚表
  PrintVFT((VF_PTR*)(*(int*)&d));
  PrintVFT((VF_PTR*)(*(int*)((char*)&d + sizeof(Base1))));
  //构成多态，同时去调用func1
  Base1* pb1 = &d;
  Base2* pb2 = &d;
  pb1->func1();
  pb2->func1();
  return 0;
}

首先我们直接给出结论：第一张虚表的func1地址是正确的地址，第二张的虚表对func1的地址进行了一定的封装。

我们在调用一个类的成员函数时，我们的this指针必须指向这个类对象的头部，否则会造成难以预料的结果，在上面的代码中，pb1是与类对象的this指针指向的是同一个位置，pb1指向的地址可以直接当成this指针去使用，但是pb2指向的位置是类对象的中间，pb2指向地址不能直接当成this指针直接去调用Derive里面的函数func1，因此用pb2调用func1时要先进行this指针的修正，修正完毕以后才能去正确的调用func1函数。

四、菱形虚拟继承与虚函数的综合

在满足上面关系的菱形虚拟继承中，如果B与C重写了A中的同一个虚函数,则D必须重写这个虚函数，(否则A的虚函数表里面不明确该存放B的重写，还是C的重写) D重写之后A的虚函数表里面放的是D的重写。

看下面的代码：

class A
{
public:
  virtual void func1()
  {
  }
  int _a;
};
class B : virtual public A
{
public:
  virtual void func1()
  {
  }
  int _b;
};
class C : virtual public A
{
public:
  virtual void func1()
  {
  }
  int _c;
};
class D : public B, public C
{
public:
  //D中不重写func1
  int _d;
};
int main()
{
  D d;
  d.B::_a = 1;
  d.C::_a = 2;
  d._b = 3;
  d._c = 4;
  d._d = 5;
  return 0;
}

结果报错

在满足上面关系的虚拟继承时，当B和C中都有自己新增的虚函数时，新增的虚函数不会放进A的虚表里面，而是放进自己的虚表里面。（因为如果都放A里面，B和C就能够相互看到对方的虚函数，这是不合理的）

class A
{
public:
  virtual void func1()
  {
  }
  int _a;
};
class B : virtual public A
{
public:
  virtual void func1()
  {
  }
  //B中新增一个独立的虚函数
  virtual void func2()
  {
  }
  int _b;
};
class C : virtual public A
{
public:
  virtual void func1()
  {
  }
  //C中新增一个独立的虚函数
  virtual void func3()
  {
  }
  int _c;
};
class D : public B, public C
{
public:
  virtual void func1()
  {
  }
  int _d;
};
int main()
{
  D d;
  d.B::_a = 1;
  d.C::_a = 2;
  d._b = 3;
  d._c = 4;
  d._d = 5;
  return 0;
}

根据此条规则，我们知道，D类中应该有3张虚函数表，2张虚基表。

我们打开内存窗口进行查看：

【C++】多态

一、多态的定义及实现

1、概念

2、多态的实现

3、虚函数

二、多态的原理

1、虚函数表

2、多态的原理

3、动态绑定与静态绑定

三、单继承和多继承关系的虚函数表

1、单继承中的虚函数表

2、多继承中的虚函数表

四、菱形虚拟继承与虚函数的综合

热门文章

最新文章

相关课程

相关电子书

相关实验场景

【C++】多态

一、多态的定义及实现

1、 概念

2、多态的实现

3、虚函数

二、多态的原理

1、虚函数表

2、多态的原理

3、动态绑定与静态绑定

三、单继承和多继承关系的虚函数表

1、单继承中的虚函数表

2、多继承中的虚函数表

四、菱形虚拟继承与虚函数的综合

热门文章

最新文章

相关课程

相关电子书

相关实验场景

1、概念