当前位置: 首页 > 编程笔记 >

C++中的多态与虚函数的内部实现方法

金赤岩
2023-03-14
本文向大家介绍C++中的多态与虚函数的内部实现方法,包括了C++中的多态与虚函数的内部实现方法的使用技巧和注意事项,需要的朋友参考一下

1、什么是多态

多态性可以简单概括为“一个接口,多种行为”。

也就是说,向不同的对象发送同一个消息, 不同的对象在接收时会产生不同的行为(即方法)。也就是说,每个对象可以用自己的方式去响应共同的消息。所谓消息,就是调用函数,不同的行为就是指不同的实现,即执行不同的函数。这是一种泛型技术,即用相同的代码实现不同的动作。这体现了面向对象编程的优越性。

多态分为两种:

(1)编译时多态:主要通过函数的重载和模板来实现。

(2)运行时多态:主要通过虚函数来实现。

2、几个相关概念

(1)覆盖、重写(override)

override指基类的某个成员函数为虚函数,派生类又定义一成员函数,除函数体的其余部分都与基类的成员函数相同。注意,如果只是函数名相同,形参或返回类型不同的话,就不能称为override,而是hide。

(2)重载(overload)

指同一个作用域出生多个函数名相同,但是形参不同的函数。编译器在编译的时候,通过实参的个数和类型,选择最终调用的函数。

(3)隐藏(hide)

分为两种:

1)局部变量或者函数隐藏了全局变量或者函数
2)派生类拥有和基类同名的成员函数或成员变量。

产生的结果:使全局或基类的变量、函数不可见。

3、几个简单的例子

/****************************************************************************************************** 
* File:PolymorphismTest 
* Introduction:测试多态的一些特性。 
* Author:CoderCong
* Date:20141114 
* LastModifiedDate:20160113 
*******************************************************************************************************/ 
#include "stdafx.h" 
#include <iostream> 
using namespace std; 
class A 
{ 
public: 
  void foo() 
  { 
    printf("1\n"); 
  } 
  virtual void fun() 
  { 
    printf("2\n"); 
  } 
}; 
class B : public A 
{ 
public: 
  void foo() //由于基类的foo函数并不是虚函数,所以是隐藏,而不是重写 
  { 
    printf("3\n"); 
  } 
  void fun() //重写 
  { 
    printf("4\n"); 
  } 
}; 
int main(void) 
{ 
  A a; 
  B b; 
  A *p = &a; 
  p->foo(); //输出1。 
  p->fun(); //输出2。 
  p = &b; 
  p->foo(); //输出1。因为p是基类指针,p->foo指向一个具有固定偏移量的函数。也就是基类函数 
  p->fun(); //输出4。多态。虽然p是基类指针,但实际上指向的是一个子类对象。p->fun指向的是一个虚函数。按照动态类型,调用子类函数   
  return 0; 
}

4、运行时多态以及虚函数的内部实现

看了上边几个简单的例子,我恍然大悟,原来这就是多态,这么简单,明白啦!

好,那我们再看一个例子:

class A 
{ 
public: 
  virtual void FunA() 
  { 
    cout << "FunA1" << endl; 
  }; 
  virtual void FunAA() 
  { 
    cout << "FunA2" << endl; 
  } 
}; 
class B 
{ 
public: 
  virtual void FunB() 
  { 
    cout << "FunB" << endl; 
  } 
}; 
class C :public A, public B 
{ 
public: 
  virtual void FunA() 
  { 
    cout << "FunA1C" << endl; 
  }; 
}; 
int _tmain(int argc, _TCHAR* argv[]) 
{ 
  C objC; 
  A *pA = &objC; 
  B *pB = &objC; 
  C *pC = &objC; 
 
  printf("%d %d\n", &objC, objC); 
  printf("%d %d\n", pA, *pA); 
  printf("%d %d\n", pB, *pB); 
  printf("%d %d\n", pC, *pC); 
 
  return 0; 
}

运行结果:

5241376 1563032

5241376 1563032

5241380 1563256

5241376 1563032

细心的同志一定发现了pB出了问题,为什么明明都是指向objC的指针,pB跟别人的值都不一样呢?

是不是编译器出了问题呢?

当然不是!我们先讲结论:

(1)每一个含有虚函数的类,都会生成虚表(virtual table)。这个表,记录了对象的动态类型,决定了执行此对象的虚成员函数的时候,真正执行的那一个成员函数。

(2)对于有多个基类的类对象,会有多个虚表,每一个基类对应一个虚表,同时,虚表的顺序和继承时的顺序相同。

(3)在每一个类对象所占用的内存中,虚指针位于最前边,每个虚指针指向对应的虚表。

先从简单的单个基类说起:

class A 
{ 
public: 
  virtual void FunA() 
  { 
    cout << "FunA1" << endl; 
  } 
  virtual void FunA2() 
  { 
    cout << "FunA2" << endl; 
  } 
}; 
 
class C :public A 
{ 
  virtual void FunA() 
  { 
    cout << "FunA1C" << endl; 
  }
}; 
int _tmain(int argc, _TCHAR* argv[]) 
{ 
  A *pA = new A; 
  C *pC = new C; 
  typedef void (*Fun)(void); 
 
  Fun fun= (Fun)*((int*)(*(int*)pA)); 
  fun();//pA指向的第一个函数 
  fun = (Fun)*((int*)(*(int*)pA) +1); 
  fun();//pA指向的第二个函数 
   
  fun = (Fun)*((int*)(*(int*)pC)); 
  fun();//pC指向的第一个函数 
  fun = (Fun)*((int*)(*(int*)pC) + 1); 
  fun();//pC指向的第二个函数 
  return 0; 
}

运行结果:

FunA1
FunA2
FunA1C
FunA2 是不是有点晕?没关系。我一点一点解释:pA对应一个A的对象,我们可以画出这样的一个表:        这就是对象*pA的虚表,两个虚函数以声明顺序排列。pA指向对象*pA,则*(int*)pA指向此虚拟表,则(Fun)*((int*)(*(int*)pA))指向FunA,同理,(Fun)*((int*)(*(int*)pA) + 1)指向FunA2。所以,出现了前两个结果。 根据后两个结果, 我们可以推测*pC的虚表如下图所示:        也就是说,由于C中的FunA重写(override)了A中的FunA,虚拟表中虚拟函数的地址也被重写了。 就是这样,这就是多态实现的内部机制。 我们再回到最初的问题:为什么*pB出了问题。 根据上边的结论,我们大胆地进行猜测:由于C是由A、B派生而来,所以objC有两个虚拟表,而由于表的顺序,pA、pC都指向了对应于A的虚拟表,而pB则指向了对应于B的虚拟表。做个实验来验证我们的猜想是否正确: 我们不改变A、B、C类,将问题中的main改一下:
int _tmain(int argc, _TCHAR* argv[]) 
{ 
  C objC; 
  A *pA = &objA; 
  B *pB = &objC; 
  C *pC = &objC; 
   
  typedef void (*Fun)(void); 
 
  Fun fun = (Fun)*((int*)(*(int*)pC)); 
  fun();//第一个表第一个函数 
  fun = (Fun)*((int*)(*(int*)pC)+1); 
  fun();//第一个表第二个函数 
  fun = (Fun)*((int*)(*((int*)pC+1))); 
  fun();<span style="white-space:pre"> </span>//第二个表第一个函数 
  fun = (Fun)*((int*)(*(int*)pB)); 
  fun();//pB指向的表的第一个函数 
  return 0; 
}

哈哈,和我们的猜测完全一致:

FunA1C
FunA2
FunB
FunB 我们可以画出这样的虚函数图:          暂且这样理解,编译器执行 B *pB = &objC时不是仅仅是赋值,而是做了相应的优化,将pB指向了第二张虚表。 说了这么多,我是只是简单地解释了虚函数的实现原理,可究竟对象的内部的内存布局是怎样的?类数据成员与多个虚表的具体内存布局又是怎样的?编译器是如何在赋值的时候作了优化的呢?我在以后的时间里会讲一下。

以上就是小编为大家带来的C++中的多态与虚函数的内部实现方法全部内容了,希望大家多多支持小牛知识库~

 类似资料:
  • 本文向大家介绍c++ 构造函数中调用虚函数的实现方法,包括了c++ 构造函数中调用虚函数的实现方法的使用技巧和注意事项,需要的朋友参考一下 我们知道:C++中的多态使得可以根据对象的真实类型(动态类型)调用不同的虚函数。这种调用都是对象已经构建完成的情况。那如果在构造函数中调用虚函数,会怎么样呢? 有这么一段代码: 输出: 0 1 2 也就是说,在构造函数中调用虚函数,调用的是正在构造的类中的虚函

  • 本文向大家介绍C++中虚函数与纯虚函数的用法,包括了C++中虚函数与纯虚函数的用法的使用技巧和注意事项,需要的朋友参考一下 本文较为深入的分析了C++中虚函数与纯虚函数的用法,对于学习和掌握面向对象程序设计来说是至关重要的。具体内容如下: 首先,面向对象程序设计(object-oriented programming)的核心思想是数据抽象、继承、动态绑定。通过数据抽象,可以使类的接口与实现分离,使

  • 本文向大家介绍c++中虚函数的实现详解,包括了c++中虚函数的实现详解的使用技巧和注意事项,需要的朋友参考一下 前言 c++ 分为编译时多态和运行时多态。运行时多态依赖于虚函数,大部分人或许听说过虚函数是由虚函数表+虚函数指针实现的,但,真的是这样吗?虽然 c++ 规范有着复杂的语言细节,但底层实现机制却任由编译器厂商想象。(没准某种特殊的处理器电路结构原生支持虚函数,没准这个处理器压根不是冯纽曼

  • 本文向大家介绍C ++中的虚函数和运行时多态,包括了C ++中的虚函数和运行时多态的使用技巧和注意事项,需要的朋友参考一下 C ++中的虚函数用于创建基类指针和任何派生类的调用方法的列表,甚至不知道派生类对象的种类。虚函数在运行时解析得较晚。 虚函数的主要用途是实现运行时多态。运行时多态只能通过基类类型的指针(或引用)来实现。同样,基类指针可以指向基类的对象以及派生类的对象。在上面的代码中,基类指

  • 本文向大家介绍C++中继承与多态的基础虚函数类详解,包括了C++中继承与多态的基础虚函数类详解的使用技巧和注意事项,需要的朋友参考一下 前言 本文主要给大家介绍了关于C++中继承与多态的基础虚函数类的相关内容,分享出来供大家参考学习,下面话不多说了,来一起看看详细的介绍吧。 虚函数类 继承中我们经常提到虚拟继承,现在我们来探究这种的虚函数,虚函数类的成员函数前面加virtual关键字,则这个成员函

  • 本文向大家介绍深入浅析C++多态性与虚函数,包括了深入浅析C++多态性与虚函数的使用技巧和注意事项,需要的朋友参考一下 派生一个类的原因并非总是为了继承或是添加新的成员,有时是为了重新定义基类的成员,使得基类成员“获得新生”。面向对象的程序设计真正的力量不仅仅是继承,而且还在于允许派生类对象像基类对象一样处理,其核心机制就是多态和动态联编。 (一)多态性   多态是指同样的消息被不同的对象接收时导