C++多态性基本概念讲述

开发 后端
C++多态性主要是通过虚函数来实现的。我们只有在重写了虚函数之后才能被看做是C++多态性。在这里将会对此做一个详细介绍。

C++编程语言是一款应用广泛,支持多种程序设计的计算机编程语言。我们今天就会为大家详细介绍其中C++多态性的一些基本知识,以方便大家在学习过程中对此能够有一个充分的掌握。#t#

前几天笔试的时候碰到考C++多态性的题目,因为不是自己的专业不是纯做软件开发,C++学习不是很好,做得有点混乱。回来以后立刻查了相关资料,大概明白了一点,可能以后解题的时候不会乱了。

先摘下一些网上的书上的基本概念。

多态性可以简单地概括为“一个接口,多种方法”,程序在运行时才决定调用的函数,它是面向对象编程领域的核心概念。多态(polymorphisn),字面意思多种形状。

C++多态性是通过虚函数来实现的,虚函数允许子类重新定义成员函数,而子类重新定义父类的做法称为覆盖(override),或者称为重写。(这里我觉得要补充,重写的话可以有两种,直接重写成员函数和重写虚函数,只有重写了虚函数的才能算作是体现了C++多态性)而重载则是允许有多个同名的函数,而这些函数的参数列表不同,允许参数个数不同,参数类型不同,或者两者都不同。编译器会根据这些函数的不同列表,将同名的函数的名称做修饰,从而生成一些不同名称的预处理函数,来实现同名函数调用时的重载问题。但这并没有体现多态性。

多态与非多态的实质区别就是函数地址是早绑定还是晚绑定。如果函数的调用,在编译器编译期间就可以确定函数的调用地址,并生产代码,是静态的,就是说地址是早绑定的。而如果函数调用的地址不能在编译器期间确定,需要在运行时才确定,这就属于晚绑定。

那么多态的作用是什么呢,封装可以使得代码模块化,继承可以扩展已存在的代码,他们的目的都是为了代码重用。而多态的目的则是为了接口重用。也就是说,不论传递过来的究竟是那个类的对象,函数都能够通过同一个接口调用到适应各自对象的实现方法。

最常见的用法就是声明基类的指针,利用该指针指向任意一个子类对象,调用相应的虚函数,可以根据指向的子类的不同而实现不同的方法。如果没有使用虚函数的话,即没有利用C++多态性,则利用基类指针调用相应的函数的时候,将总被限制在基类函数本身,而无法调用到子类中被重写过的函数。因为没有多态性,函数调用的地址将是一定的,而固定的地址将始终调用到同一个函数,这就无法实现一个接口,多种方法的目的了。

笔试的题目

  1. #include <stdio.h> 
  2. class A  
  3. {  
  4. public:  
  5. void foo()  
  6. {  
  7. printf("1");  
  8. }  
  9. virtual void fuu()  
  10. {  
  11. printf("2");  
  12. }  
  13. };  
  14. class B:public A  
  15. {  
  16. public:  
  17. void foo()  
  18. {  
  19. printf("3");  
  20. }  
  21. void fuu()  
  22. {  
  23. printf("4");  
  24. }  
  25. };  
  26. int main()  
  27. {  
  28. A a;  
  29. B b;  
  30. A *p = &a;  
  31. p->foo();  
  32. p->fuu();  
  33. p = &b;  
  34. p->foo();  
  35. p->fuu();  
  36. return 0;  

第一个p->foo()和p->fuu()都很好理解,本身是基类指针,指向的又是基类对象,调用的都是基类本身的函数,因此输出结果就是1、2。

第二个p->foo()和p->fuu()则是基类指针指向子类对象,正式体现多态的用法,p->foo()由于指针是个基类指针,指向是一个固定偏移量的函数,因此此时指向的就只能是基类的foo()函数的代码了,因此输出的结果还是1。而p->fuu()指针是基类指针,指向的fuu是一个虚函数,由于每个虚函数都有一个虚函数列表,此时p调用fuu()并不是直接调用函数,而是通过虚函数列表找到相应的函数的地址,因此根据指向的对象不同,函数地址也将不同,这里将找到对应的子类的fuu()函数的地址,因此输出的结果也会是子类的结果4.

笔试的题目中还有一个另类测试方法。即

 

  1. B *ptr = (B *)&a;  
  2. ptr->foo();  
  3. ptr->fuu(); 

 

问这两调用的输出结果。这是一个用子类的指针去指向一个强制转换为子类地址的基类对象。结果,这两句调用的输出结果是3,2。

并不是很理解这种用法,从原理上来解释,由于B是子类指针,虽然被赋予了基类对象地址,但是ptr->foo()在调用的时候,由于地址偏移量固定,偏移量是子类对象的偏移量,于是即使在指向了一个基类对象的情况下,还是调用到了子类的函数,虽然可能从始到终都没有子类对象的实例化出现。

而ptr->fuu()的调用,可能还是因为C++多态性的原因,由于指向的是一个基类对象,通过虚函数列表的引用,找到了基类中foo()函数的地址,因此调用了基类的函数。由此可见多态性的强大,可以适应各种变化,不论指针是基类的还是子类的,都能找到正确的实现方法。

责任编辑:曹凯 来源: 博客园
相关推荐

2010-02-05 17:34:37

C++函数模板

2010-01-28 16:16:32

C++多态性

2009-09-01 15:08:18

C#多态性

2009-08-28 16:48:50

C#多态性

2010-02-03 13:22:07

C++时间

2010-02-05 12:57:20

C++ kdevelo

2010-02-02 10:33:22

C++引用

2010-02-02 15:30:05

C++ include

2010-02-03 11:11:18

C++类型转换

2010-02-02 13:41:01

C++类继承

2010-02-01 17:24:41

C++循环语句

2010-02-03 14:36:47

C++仿函数

2010-02-04 10:08:00

C++静态成员函数

2010-02-06 14:04:58

C++内存使用机制

2010-02-04 13:56:24

C++类模板特化

2009-09-01 14:51:19

C#多态性

2010-01-15 13:30:50

VB.NET Prog

2010-02-06 09:53:26

C++ void

2010-02-04 17:39:48

C++字符串类型

2010-02-06 15:58:10

C++集合初始化
点赞
收藏

51CTO技术栈公众号