个人中心
gpt4 book ai didi

C++面向对象之多态的实现和应用详解

转载 作者：qq735679552 更新时间：2022-09-28 22:32:09 27 4
gpt4 key购买 nike

CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章C++面向对象之多态的实现和应用详解由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

前言 。

本文主要给大家介绍的是关于C++面向对象之多态的实现和应用的相关内容，分享出来供大家参考学习，下面话不多说了，来一起看看详细的介绍吧.

多态 。

大家应该都听过C++三大特性之一多态，那么什么多态呢？多态有什么用？通俗一点来讲-> 。

多态性可以简单地概括为“一个接口，多种方法”，程序在运行时才决定调用的函数，它是面向对象编程领域的核心概念。当多态应用形参类型的时候，可以接受更多的类型。当多态用于返回值类型的时候，可以返回更多类型的数据。多态可以让你的代码拥有更好的扩展性.

多态分两种分别为静态多态和动态多态:

  • 静态多态：静态多态就是重载，因为是在编译期决议确定，所以称为静态多态。
  • 动态多态：动态多态就是通过继承重写基类的虚函数实现的多态，因为是在运行时决议确定，所以称为动态多态。

而我们主要今天来看动态多态的问题。比如我们来看下面的代码，就是简单的动态多态:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
class Person
{
public :
  virtual void BuyTickets()
  {
  cout << " 买票" << endl;
  }
 
protected :
  string _name; // 姓名
};
 
class Student : public Person
{
public :
  virtual void BuyTickets()
  {
  cout << " 买票-半价 " << endl;
  }
 
protected :
  int _num; //学号
};
 
void Fun(Person& p)
{
  p.BuyTickets();
}
 
void Test()
{
  Person p;
  Student s;
  Fun(p);
  Fun(s);
}
int main()
{
  Test();
  system ( "pause" );
  return 0;
}

C++面向对象之多态的实现和应用详解

构成多态的四大条件: (缺一不可) 。

      1.不在同一作用域（分别在父类和子类） 。

      2.函数名相等/参数相等/返回值相同/（协变除外） 。

      3.基类函数必须有virtual关键字 。

      4.访问修饰符可以不同 。

具体多态是如何实现的？？ 这里我们先从虚函数表这个知识点讲起，每一个带有虚函数的对象都会有一个虚函数表，虚函数表里存的是函数指针，然后调用的时候，指针回去虚函数表里面访问查找。对于这个知识点我的另外一个博客很详细的讲解到，大家可以先看看这个:http://www.zzvips.com/article/167775.html 。

然后我们来了解一下重写是什么东西？

重写的过程 。

C++面向对象之多态的实现和应用详解

如果这块还是不理解，你可以看我专门写虚函数那片博客，仔细看一定会看懂的. 。

接下来多态的原理我们就明白了吧. 发生重写之后，下一次父类指针指向我调用fun()函数的时候，它调用到的就是子类的fun(）函数，其实多态就是这么简单，只要理解重写就理解多态. 虚函数表是我们必须掌握的一个知识点. 。

通过汇编来分析多态的实现 。

好了，我们继续往下走，刚刚我们从虚函数表这方面，探究了多态的实现，现在我们再从汇编的角度再来看多态是如何实现的.

我们来看一段新的代码:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
class Person
{
public :
  virtual void BuyTickets()
  {
  cout << " 买票" << endl;
  }
 
protected :
  string _name; // 姓名
};
 
class Student : public Person
{
public :
  virtual void BuyTickets()
  {
  cout << " 买票-半价 " << endl;
  }
 
protected :
  int _num; //学号
};
void Fun(Person& p)
{
  p.BuyTickets();
}
 
void Test()
{
  Person p;
  Student q;
  Person* ptr = &q;
  p.BuyTickets();
  ptr->BuyTickets();
}
int main()
{
  Test();
  system ( "pause" );
  return 0;
}

打开我们的反汇编窗口:

C++面向对象之多态的实现和应用详解

这里我们看到用指向子类的父类类型指针调用BuyTickets函数和直接用对象调用汇编代码相差巨大，一个只有2句话，一个那么长，这是因为在发生多态时当你用指针调用时，系统不知道你要用哪一个函数，因为这里有多态现象，所以系统只能老实的去虚函数表里查找，所以才会有这么多的代码，接下来我们来解释一下这些汇编，来看看系统是调用虚表的.

C++面向对象之多态的实现和应用详解

这里我们就关心到了那四个红色的句子，可以看到这里一直都是想讲虚函数表的地址传给系统，然后再传this指针，就可以调用哪个函数了。蓝色的就是一个小知识~ 知道有这么个东西就好了. 。

虚函数是在基类中定义的，目的是不确定它的派生类的具体行为。例:

  1. 定义一个基类：class Animal//动物。它的函数为breathe()//呼吸。
  2. 再定义一个类class Fish//鱼 。它的函数也为breathe()
  3. 再定义一个类class Sheep //羊。它的函数也为breathe()
  4. 为了简化代码，将Fish,Sheep定义成基类Animal的派生类。

然而Fish与Sheep的breathe不一样，一个是在水中通过水来呼吸，一个是直接呼吸空气。所以基类不能确定该如何定义breathe，所以在基类中只定义了一个virtual breathe,它是一个空的虚函数。具本的函数在子类中分别定义。程序一般运行时，找到类，如果它有基类，再找它的基类，最后运行的是基类中的函数，这时，它在基类中找到的是virtual标识的函数，它就会再回到子类中找同名函数。派生类也叫子类。基类也叫父类。这就是虚函数的产生，和类的多态性（breathe）的体现.

 一般情况下（没有涉及virtual函数），当我们用一个指针/引用调用一个函数的时候，被调用的函数是取决于这个指针/引用的类型。即如果这个指针/引用是基类对象的指针/引用就调用基类的方法；如果指针/引用是派生类对象的指针/引用就调用派生类的方法，当然如果派生类中没有此方法，就会向上到基类里面去寻找相应的方法。这些调用在编译阶段就确定了.

当设计到多态性的时候，采用了虚函数和动态绑定，此时的调用就不会在编译时候确定而是在运行时确定。不在单独考虑指针/引用的类型而是看指针/引用的对象的类型来判断函数的调用，根据对象中虚指针指向的虚表中的函数的地址来确定调用哪个函数.

现在我们来一个小练习:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
#include<iostream>
#include<Windows.h>
using namespace std;
 
class A
{
public :
  void foo()
  {
  printf ( "1\n" );
  }
  virtual void fun()
  {
  printf ( "2\n" );
  }
};
class B : public A
{
public :
  void foo()
  {
  printf ( "3\n" );
  }
  void fun()
  {
  printf ( "4\n" );
  }
};
int main( void )
{
  A a;
  B b;
  A *p = &a;
  p->foo();
  p->fun();
  p = &b;
  p->foo();
  p->fun();
  system ( "pause" );
  return 0;
}

这道题的运行结果分别是 1 2 1 4,，现在我们来分析为什么?

首先当一个父类类型指针指向父类时，我们应该知道这里没有多态，该怎么调用就怎么调用，所以调用了父类里面的foo函数和fun函数。现在我们重点来看后面这个，现在B继承了A，我们先判断这里是否有多态现象（1.父类和子类是否有重写现象 2.是否有父类类型的指针指向子类），现在很明显子类的fun函数重写了父类的fun函数，所以现在p->fun()调用的就是子类的fun函数，然后foo函数，根本不构成多态，所以这里指针类型是什么那个对象就按那个对象调用。总结一下当你碰到关于继承的问题，首先判断它里面是否有多态现象，如果没有那就根据指针/引用类型调用。如果有多态的话，一定要注意根据指针/引用的指向对象判断.

总结 。

以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作具有一定的参考学习价值，如果有疑问大家可以留言交流，谢谢大家对我的支持.

原文链接：http://blog.csdn.net/dawn_sf/article/details/69223132 。

最后此篇关于C++面向对象之多态的实现和应用详解的文章就讲到这里了,如果你想了解更多关于C++面向对象之多态的实现和应用详解的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。

27 4 0
文章推荐： php实现多站点共用session实现单点登录的方法详解
文章推荐： DBA必备知识｜Oracle 托管文件 (OMF)详解
文章推荐： PHP实现批量修改文件名的方法示例
文章推荐： 聊聊 MySQL 中的游标
qq735679552
个人简介

我是一名优秀的程序员,十分优秀！

滴滴打车优惠券免费领取
滴滴打车优惠券
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com