关于C++多态的理解

最新推荐文章于 2022-03-15 17:19:56 发布
最新推荐文章于 2022-03-15 17:19:56 发布
阅读量341 收藏
点赞数
分类专栏： MFC学习笔记 文章标签： c++ 面向对象 类
 类的多态特性是支持面向对象的语言最主要的特性，有过非面向对象语言开发经历的人，通常对这一章节的内容会觉得不习惯，因为很多人错误的认为，支持类的封装的语言就是支持面向对象的，其实不然，Visual BASIC 6.0 是典型的非面向对象的开发语言，但是它的确是支持类，支持类并不能说明就是支持面向对象，能够解决多态问题的语言，才是真正支持面向对象的开发的语言，所以务必提醒有过其它非面向对象语言基础的读者注意！  

        多态的这个概念稍微有点模糊，如果想在一开始就想用清晰用语言描述它，让读者能够明白，似乎不太现实，所以我们先看如下代码：

//例程１ 

01 #include <iostream>     
02 using namespace std;   
03      
04 class Vehicle
05 {   
06 public:   
07      Vehicle(float speed,int total)
08      {
09          Vehicle::speed=speed;
10          Vehicle::total=total;
11      }
12     void ShowMember()
13      {
14         cout<<speed<<"|"<<total<<endl;
15      }
16 protected:   
17     float speed;
18     int total;
19 };   
20 class Car:public Vehicle   
21 {   
22 public:   
23      Car(int aird,float speed,int total):Vehicle(speed,total)   
24      {   
25          Car::aird=aird;   
26      }


      void  ShowMember() 但是在实际工作中，很可能会碰到对象所属类不清的情况，下面我们来看一下派生类成员作为函数参数传递的例子，代码如下：

//例程２ 

01 #include <iostream>     
02 using namespace std;   
03      
04 class Vehicle
05 {   
06 public:   
07      Vehicle(float speed,int total)
08      {
09          Vehicle::speed=speed;
10          Vehicle::total=total;
11      }
12     void ShowMember()
13      {
14         cout<<speed<<"|"<<total<<endl;
15      }
16 protected:   
17     float speed;
18     int total;
19 };   
20 class Car:public Vehicle   
21 {   
22 public:   
23      Car(int aird,float speed,int total):Vehicle(speed,total)   
24      {   
25          Car::aird=aird;   
26      }
27     void ShowMember()
28      {
29         cout<<speed<<"|"<<total<<"|"<<aird<<endl;
30      }
31 protected:   
32     int aird;
33 };   
34  
35 void test(Vehicle &temp)
36 {
37      temp.ShowMember();
38 }
39  
40 void main()   
41 {
42      Vehicle a(120,4);
43      Car b(180,110,4);
44      test(a);
45      test(b);
46     cin.get();
47 }

　 　例子中，对象a与b分辨是基类和派生类的对象，而函数test的形参却只是Vehicle类的引用，按照类继承的特点，系统把Car类对象看做是一个 Vehicle类对象，因为Car类的覆盖范围包含Vehicle类，所以test函数的定义并没有错误，我们想利用test函数达到的目的是，传递不同 类对象的引用，分别调用不同类的,重载了的,ShowMember成员函数，但是程序的运行结果却出乎人们的意料，系统分不清楚传递过来的基类对象还是派生类对象，无论是基类对象还是派生类对象调用的都是基类的ShowMember成员函数。

01   {
02         cout<<speed<<"|"<<total<<"|"<<aird<<endl;
03      }
04 protected:   
05     int aird;
06 };   
07  
08 void main()   
09 {   
10      Vehicle a(120,4);
11      a.ShowMember();
12      Car b(180,110,4);
13      b.ShowMember();
14     cin.get();
15 }

　 　在c++中是允许派生类重载基类成员函数的，对于类的重载来说，明确的，不同类的对象，调用其类的成员函数的时候，系统是知道如何找到其类的同名成员， 上面代码中的a.ShowMember();，即调用的是Vehicle::ShowMember()，b.ShowMember();，即调用的是 Car::ShowMemeber();。

但是在实际工作中，很可能会碰到对象所属类不清的情况，下面我们来看一下派生类成员作为函数参数传递的例子，代码如下：

//例程２ 

01 #include <iostream>     
02 using namespace std;   
03      
04 class Vehicle
05 {   
06 public:   
07      Vehicle(float speed,int total)
08      {
09          Vehicle::speed=speed;
10          Vehicle::total=total;
11      }
12     void ShowMember()
13      {
14         cout<<speed<<"|"<<total<<endl;
15      }
16 protected:   
17     float speed;
18     int total;
19 };   
20 class Car:public Vehicle   
21 {   
22 public:   
23      Car(int aird,float speed,int total):Vehicle(speed,total)   
24      {   
25          Car::aird=aird;   
26      }
27     void ShowMember()
28      {
29         cout<<speed<<"|"<<total<<"|"<<aird<<endl;
30      }
31 protected:   
32     int aird;
33 };   
34  
35 void test(Vehicle &temp)
36 {
37      temp.ShowMember();
38 }
39  
40 void main()   
41 {
42      Vehicle a(120,4);
43      Car b(180,110,4);
44      test(a);
45      test(b);
46     cin.get();
47 }

　 　例子中，对象a与b分辨是基类和派生类的对象，而函数test的形参却只是Vehicle类的引用，按照类继承的特点，系统把Car类对象看做是一个 Vehicle类对象，因为Car类的覆盖范围包含Vehicle类，所以test函数的定义并没有错误，我们想利用test函数达到的目的是，传递不同 类对象的引用，分别调用不同类的,重载了的,ShowMember成员函数，但是程序的运行结果却出乎人们的意料，系统分不清楚传递过来的基类对象还是派生类对象，无论是基类对象还是派生类对象调用的都是基类的ShowMember成员函数。

为了要解决上述不能正确分辨对象类型的问题，c++提供了一种叫做多态性（polymorphism）的技术来解决问题，对于例程序１，这种能够在编译时就能够确定哪个重载的成员函数被调用的情况被称做先期联编（early binding），而在系统能够在运行时，能够根据其类型确定调用哪个重载的成员函数的能力，称为多态性，或叫滞后联编(late binding)，下面我们要看的例程３，就是滞后联编，滞后联编正是解决多态问题的方法。 

代码如下：

//例程３ 

01 #include <iostream>     
02 using namespace std;   
03      
04 class Vehicle
05 {   
06 public:   
07      Vehicle(float speed,int total)
08      {
09          Vehicle::speed = speed;
10          Vehicle::total = total;
11      }
12     virtual void ShowMember()//虚函数
13      {
14         cout<<speed<<"|"<<total<<endl;
15      }
16 protected:   
17     float speed;
18     int total;
19 };   
20 class Car:public Vehicle   
21 {   
22 public:   
23      Car(int aird,float speed,int total):Vehicle(speed,total)   
24      {   
25          Car::aird = aird;   
26      }
27     virtual void ShowMember()//虚函数,在派生类中，由于继承的关系，这里的virtual也可以不加
28      {
29         cout<<speed<<"|"<<total<<"|"<<aird<<endl;
30      }
31 public:   
32     int aird;
33 };
34  
35 void test(Vehicle &temp)
36 {
37      temp.ShowMember();
38 }
39  
40 int main()   
41 {   
42      Vehicle a(120,4);
43      Car b(180,110,4);
44      test(a);
45      test(b);
46     cin.get();
47 }

　　多态特性的工作依赖虚函数的定义，在需要解决多态问题的重载成员函数前，加上virtual关键字，那么该成员函数就变成了虚函数，从上例代码运行的结果看，系统成功的分辨出了对象的真实类型，成功的调用了各自的重载成员函数。

　　多态特性让程序员省去了细节的考虑，提高了开发效率，使代码大大的简化，当然虚函数的定义也是有缺陷的，因为多态特性增加了一些数据存储和执行指令的开销，所以能不用多态最好不用。

 

虚函数的定义要遵循以下重要规则： 

　　1.如果虚函数在基类与派生类中出现，仅仅是名字相同，而形式参数不同，或者是返回类型不同，那么即使加上了virtual关键字，也是不会进行滞后联编的。 

2.只有类的成员函数才能说明为虚函数，因为虚函数仅适合用与有继承关系的类对象，所以普通函数不能说明为虚函数。 

3.静态成员函数不能是虚函数,因为静态成员函数的特点是不受限制于某个对象。 

4.内联(inline)函数不能是虚函数，因为内联函数不能在运行中动态确定位置。即使虚函数在类的内部定义定义，但是在编译的时候系统仍然将它看做是非内联的。 

5.构造函数不能是虚函数，因为构造的时候，对象还是一片位定型的空间，只有构造完成后，对象才是具体类的实例。 

6.析构函数可以是虚函数,而且通常声名为虚函数。 

说明一下，虽然我们说使用虚函数会降低效率，但是在处理器速度越来越快的今天，将一个类中的所有成员函数都定义成为virtual总是有好处的，它除了会增加一些额外的开销是没有其它坏处的，对于保证类的封装特性是有好处的。

　　对于上面虚函数使用的重要规则6，我们有必要用实例说明一下，为什么具备多态特性的类的析构函数，有必要声明为virtual。 

代码如下：

01 #include <iostream>     
02 using namespace std;   
03      
04 class Vehicle
05 {   
06 public:  
07      Vehicle(float speed,int total)
08      {
09          Vehicle::speed=speed;
10          Vehicle::total=total;
11      }
12     virtual void ShowMember()
13      {
14         cout<<speed<<"|"<<total<<endl;
15      }
16     virtual ~Vehicle()
17      {
18         cout<<"载入Vehicle基类析构函数"<<endl;
19         cin.get();
20      }
21 protected:   
22     float speed;
23     int total;
24 };   
25 class Car:public Vehicle   
26 {   
27 public:   
28      Car(int aird,float speed,int total):Vehicle(speed,total)   
29      {   
30          Car::aird=aird;   
31      }
32     virtual void ShowMember()
33      {
34         cout<<speed<<"|"<<total<<"|"<<aird<<endl;
35      }
36     virtual ~Car()
37      {
38         cout<<"载入Car派生类析构函数"<<endl;
39         cin.get();
40      }
41 protected:   
42     int aird;
43 };   
44  
45 void test(Vehicle &temp)
46 {
47      temp.ShowMember();
48 }
49 void DelPN(Vehicle *temp)
50 {
51     delete temp;
52 }
53 void main()
54 {   
55      Car *a=new Car(100,1,1);
56      a->ShowMember();
57      DelPN(a);
58     cin.get();
59 }

　 　从上例代码的运行结果来看，当调用DelPN(a);后，在析构的时候，系统成功的确定了先调用Car类的析构函数，而如果将析构函数的virtual 修饰去掉，再观察结果，会发现析构的时候，始终只调用了基类的析构函数，由此我们发现，多态的特性的virtual修饰，不单单对基类和派生类的普通成员 函数有必要，而且对于基类和派生类的析构函数同样重要。

ziyouqishi45
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++多态理解与认识
weixin_48937110的博客
01-26 1357
1.什么是多态？ 多态是指函数调用的多种形态，使我们调用函数更加灵活。 多态分为静态多态与动态多态 1）静态多态：静态多态指的是编译时的多态，通过函数重载实现。根据函数命名规则找到函数地址，从而实现调用不同的方法。 2）动态多态（运行时）：父类指针或引用调用重写虚函数 a.父类指针或引用指向父类，调用的就是父类的虚函数，指向哪个子类就去调用哪个子类里相应的虚函数。 动态的多态构成的条件： 1）必须通过基类的指针或者引用调用虚函数 2）被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写。 满足多态的
C++之多态详解
最新发布
be_a_struggler的博客
11-15 2702
C++多态，多态的概念，多态的定义及实现，虚函数，虚函数的重写，抽象类，多态的原理，单继承和多继承关系中的虚函数表 多态常见的面试题
C++多态的实现机制深入理解
12-26
在面试过程中C++的多态实现机制经常会被面试官问道。大家清楚多态到底该如何实现吗？下面小编抽空给大家介绍下多态的实现机制。 1. 用virtual关键字申明的函数叫做虚函数，虚函数肯定是类的成员函数。 2. 存在虚函数的类都有一个一维的虚函数表叫做虚表。类的对象有一个指向虚表开始的虚指针。虚表是和类对应的，虚表指针是和对象对应的。 3. 多态性是一个接口多种实现，是面向对象的核心。分为类的多态性和函数的多态性。 4. 多态用虚函数来实现，结合动态绑定。 5. 纯虚函数是虚函数再加上= 0。 6. 抽象类是指包括至少一个纯虚函数的类。 多态的简单介绍 一般来说，多态分为两种，静态
【C++学习笔记（十七）】之多态的理解
开发小鸽
07-17 206
一. 多态        多态是面向对象程序设计语言中数据抽象和继承之外的第三个基本特征。        多态性改善了代码的可读性和组织性，同时也使创建的程序具有可扩展性，项目不仅在最初创建时期可以扩展，而且当项目在需要有新的功能时也能扩展。 二. 多态的类型        C++支持静态多态（编译时多态）和动态多态（运行时多态）。     &n
C++ 多态理解
qq_34068766的博客
07-19 768
多态 什么是多态？？？？ 其实也可以说是一种接口，多种实现方法。 分为静态多态和动态多态。 静态多态分为函数重载和泛型编程，也可以说是静态联编,在编译期间就可以确定了。 函数重载主要是函数的参数列表的不同（数据类型的不同和参数个数的不同） 泛型编程就是建立一个模板，输入不同的数据类型也可以实现想要的功能。 动态多态，也可以说是动态联编，根据虚函数调用不同的函数，根据函数调用的动态...
【C++】多态的理解
alidada_blog的博客
11-09 471
一.多态的概念 简单的讲就是同一事物在不同条件下所呈现出来的不同形态 举例：火车站的同一窗口成人售票就是全价票，学生就是半价票。这就是同一事物，但是在不同的条件下可以呈现处不同的形态。有点见人说人话，见鬼说鬼话的意思。 二.多态的实现 #include&lt;iostream&gt; #include&lt;Windows.h&gt; using namespace std; cla...
c++：多态的详解（理解）
W_J_F_的博客
10-07 858
目录 1多态概念： 2多态实现： 2.1虚函数 2.2重写（覆盖） 2.3重载，覆盖（重写），隐藏（重定义）的区别​ 2.4多态的构成条件 2.5动态绑定与静态绑定 3抽象类 4带有虚函数对象模型剖析 1：包含有虚函数的类对象与普通类对象的区别 2：虚函数表 3：打印虚表 5基类与派生类虚表中内容 6对象模型 1：虚函数调用过程 2：单继承 3：多...
C++多态Demo
05-01
这个“C++多态Demo”示例中，我们看到长方形和三角形作为形状（Shape）类的派生类，体现了面向对象编程中的继承和多态概念。 首先，让我们来理解一下基础的面向对象概念： 1. **类（Class）**: 类是创建对象的蓝图...
C++多态的实例
hpx12345678的博客
10-12 554
1.1 多态的概念 简单理解：同一个接口，多种实现方式，让不同类的的对象对同一件事情可以采用不同方法去做 1.2 多态的作用 （1）应用程序可以不必为一个派生类编写功能调用，而只需要对抽象基类进行处理即可，实现代码重用； （2）派生类的功能可以被基类的方法或引用变量调用，这称作向后兼容。 1.3多态实现 动态分为动态多态，静态多态，函数多态和宏多态，编程者的动态多态通常是指动态多态，是是基于继承机制和虚函数实现的。 2.1动态的实例 (1)用指针来来实现多态: #include<iostrea
C++三大特性之多态
热门推荐
eagle_007WH的博客
11-16 1万+
多态 编译环境：VS2013 一、对象类型 在引入多态之前，我们先来看一下对象类型   二、多态性的概念      多态一词最初来源于希腊语，意思是具有多种形式或形态的情形，在C++中是指同样的消息被不同类型的对象接收时导致不同的行为，这里讲的消息就是指对象的成员函数的调用，而不同的行为是指不同的实现。也就是调用了不同的函数。      概念的给出总是那么的抽象，我们来通过一个具体的
第二十二篇：C++中的多态机制
weixin_33890526的博客
01-26 87
前言        封装性，继承性，多态性是面向对象语言的三大特性。其中封装，继承好理解，而多态的概念让许多初学者感到困惑。本文将讲述C++中多态的概念以及多态的实现机制。 什么是多态？        多态就是多种形态，就是许多情况下可以互换地使用基类型和派生类型的多种形态。 多态的实现        依赖于动态绑定机制。 动态绑定机制相关        动态绑定是函数实际参数和形式...
面试题---对C++中多态的理解
xt18971492243的博客
02-27 426
多态&lt;1&gt;前序多态，顾名思义，是指一段程序能够有处理多个对象的能力。可以理解为“一个接口，多个方法”。程序在运行时才决定调用的函数。同一个操作作用于不同的对象，调用不同的函数，产生不同的执行结果。(通过指向父类的指针，来调用子类的函数)，从而实现接口重用。多态一般由虚函数来实现。&lt;2&gt;虚函数虚函数注意是为实现多态而设定的。当我们想要用父类的指针保存子类的对象，希望子类和基类...
浅析C++中的多态
Delete&_all的博客
11-11 382
多态的引出 多态（polymorphism）一词最初来源与希腊，意思是具有多种形态或形式的情形，多态性是面向对象程序设计的一个重要特征。利用多态性可以设计和实现一个易于扩展的系统。 静态多态 静态多态又称静态链接或者早绑定。 编译器在编译期间完成的，编译器根据函数实参的类型（可能会进行隐式类型转换），可推断出要调用那个函数，如果有对应的函数就调用该函数，否则出现编译错误。 #de
C++ 什么是多态
dee53994040的博客
09-02 409
一．什么是多态（Polymorphism） 多态（Polymorphism）是面向对象（Object-Oriented，OO）思想"三大特征"之一，其余两个分别是封装（Encapsulation）和继承（Inheritance）--可见多态的重要性。或者说，不懂得什么是多态就不能说懂得面向对象。 多态是一种机制、一种能力，而非某个关键字。它在类的继承中得以实现，在类的方法调用中得以体...
说一下你对多态的理解?_C++ 一篇搞懂多态的实现原理
weixin_39880621的博客
11-22 470
虚函数和多态01 虚函数在类的定义中，前面有 virtual 关键字的成员函数称为虚函数；virtual 关键字只用在类定义里的函数声明中，写函数体时不用。class 02 多态的表现形式一「派生类的指针」可以赋给「基类指针」；通过基类指针调用基类和派生类中的同名「虚函数」时:若该指针指向一个基类的对象，那么被调用是 基类的虚函数；若该指针指向一个派生类的对象，那么被调用 的是派生类的虚函数。这种...
对c++多态的理解
duhuzhen的博客
12-15 412
转自：http://blog.csdn.net/hackbuteer1/article/details/7475622 1 什么是多态？ 多态性可以简单的概括为“1个接口，多种方法”，在程序运行的过程中才决定调用的机制 程序实现上是这样，通过父类指针调用子类的函数，可以让父类指针有多种形态。 2 实现机制 举一个例子： #include class animal { pub
个人对C++多态的看法
03-05 902
前言： 实例往往更能让人接受，只有接受了，才有更好地运用。 本文未必准确，只是帮助理解，若有谬误，望指正。 实例： 有一天，我很无聊，打算外出游玩。于是，我在朋友圈发“若谁有空，请联系我，一同游玩。” 同学的电话来了，我与之外出，去商业区，吃、MOIVE、K歌。 父母的电话来了，我与之外出，去公园，散步、谈心。 稍微抽象下： f ：我.外出（人）; //我确定的是
php c++多态区别,C++复习要点总结之十——多态（一）
weixin_36191781的博客
03-09 107
多态的理解：是一个面向对象新需求：根据实际的对象类型来判断重写函数的调用如果父类指针指向的是父类对象则调用父类中定义的函数如果父类指针指向的是子类对象则调用子类中定义的重写函数解决方案：Ø C++中通过virtual关键字对多态进行支持Ø 使用virtual声明的函数被重写后即可展现多态特性//面向对象3大概念封装突破了C语言函数的概念。。继承代码复用 。。。。我复用原来写好的代码。。。多态多态可...
C++多态的理解
weixin_44244332的博客
03-15 5932
1.多态的概念及分类 多态是面向对象程序设计的一个重要特征。多态的字面意思就是多种状态，在面向对象的程序设计中，一个接口，多种实现即为多态。c++的多态性具体体现在编译和运行两个阶段。编译时多态是静态多态，在编译时就可以确定使用的接口。运行时多态是动态多态，具体引用的接口在运行时才能确定。 静态多态和动态多态区别其实只是在什么时候将函数实现和函数调用关联起来，是在编译时期还是运行时期，即函数地址是早绑定还是晚绑定。静态多态是指在编译期间就可以确定函数的调用地址，并产生代码，这是静态的，也就是说地址是早绑
深入理解C++多态与虚函数表
"C++ 多态 虚表 分析 图解 .doc" 在C++编程语言中，多态性是面向对象编程的核心概念之一，它允许程序员使用一个父类类型的指针或引用来调用实际...理解和掌握这一机制对深入学习C++和进行高效的面向对象编程至关重要。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值