C++和java多态的区别

开发 开发工具
C++和java都具多态性,多态性其实就是方法调用的机制,也就是说当在编译时无法确定一个对象的实际类型时,应当能够在运行时基于对象的实际类型来决定调用的具体方法。本文主要介绍C++和java多态的区别。

  以前我有个错误的观点:即使在C++java多态性的实现机制可能不同,但它们的表现形式应该相同,也就是说如果代码结构相同,那么执行结果也应该相同。可惜事与愿违,事情并不总是我想象中的那样子,那么C++和java多态到底有何区别呢?

  首先我们提一下多态性的概念。根据Bjarne Stoustrup的说法,多态性其实就是方法调用的机制,也就是说当在编译时无法确定一个对象的实际类型时,应当能够在运行时基于对象的实际类型来决定调用的具体方法(动态绑定)。

  我们先来看一下在C++中的函数调用方式:

  • 普通函数调用:具体调用哪个方法在编译时间就可以决定(通过查找编译器的符号表),同时在使用标准过程调用机制基础上增加一个表示对象身份的指针(this指针)。
  • 虚函数调用:函数调用依赖于对象的实际类型,一般地说,对象的实际类型只能在运行时间才能确定。虚函数一般要有两个步骤来支持,首先每一个类产生出一堆指向虚函数的指针,放在表格中,这个表格就叫虚函数表(virtual table);然后每一个类对象(class object)会添加一个指向相关虚函数表(virtual table)的指针,通常这个指针叫做vptr。

  在java中又是如何的呢?恩,区别还是满大的。在java虚拟机中,类实例的引用就是指向一个句柄(handle)的指针,而该句柄(handle)其实是一对指针:其中一个指针指向一张表,该表格包含了对象的方法列表以及一个指向类对象(表示对象类型)的指针;另一个指针指向一块内存地址,该内存是从java堆中为对象的数据而分配出来的。

  这时,你可能会说,好象差不多嘛,不是都要维护一张函数表吗?别急,让我们先看一下例子,这样你就能更好的理解它们之间的区别到底有多大了。

  下面是C++和java的例子,不看后面的答案,你能够正确说出它们的执行结果吗?

  例1:C++

  1.   class Base   
  2.   {   
  3.   public:   
  4.   Base()   
  5.   {   
  6.   init();   
  7.   }   
  8.   virtual ~Base() {}   
  9.   public:   
  10.   virtual void do_init()   
  11.   {   
  12.   init();   
  13.   }   
  14.   protected:   
  15.   virtual void init()   
  16.   {   
  17.   cout << "in Base::init()" << endl;   
  18.   }   
  19.   };   
  20.   class Derived : public Base   
  21.   {   
  22.   public:   
  23.   Derived()   
  24.   {   
  25.   init();   
  26.   }   
  27.   protected:   
  28.   void init()   
  29.   {   
  30.   cout << "in Derived::init()" << endl;   
  31.   }   
  32.   };   
  33.   int main(int argc, char* argv[])   
  34.   {   
  35.   Base* pb;   
  36.   pb = new Derived();   
  37.   delete pb;   
  38.   return 0;   
  39.   }      

  例2:java

  1. class Base   
  2.   {   
  3.   public Base()   
  4.   {   
  5.   init();   
  6.   }   
  7.   protected void init()   
  8.   {   
  9.   System.out.println("in Base::init()");   
  10.   }   
  11.   public void do_init()   
  12.   {   
  13.   init();  
  14.    }  
  15.    }   
  16.   class Derived extends Base   
  17.   {   
  18.   public Derived()   
  19.   {   
  20.   init();   
  21.   }   
  22.   protected void init()   
  23.   {   
  24.   System.out.println("in Derived::init()");  
  25.   }   
  26.   }   
  27.   public class Test   
  28.   {   
  29.   public static void main(String[] args)   
  30.   {   
  31.   Base base = new Derived();   
  32.   }   
  33.   }      

  例1的执行结果是:

  1. in Base::init()   
  2. in Derived::init()      

  例2的执行结果是:

  1. in Derived::init()   
  2. in Derived::init()  
  3.      

  看了结果后,你是马上顿悟呢抑或是处于疑惑中呢?ok,我们来分析一下两个例子的执行过程。

  首先看一下例1(C++的例子):

  1. Base* pb; 只是声明,不做什么。

  2. pb = new Derived();

  1) 调用new操作符,分配内存。

  2) 调用基类(本例中是Base)的构造函数

  3) 在基类的构造函数中调用init(),执行程序首先判断出当前对象的实际类型是Base(Derived还没构造出来,当然不会是Derived),所以这里调用的是Base::init()。

  4) 调用派生类(本例中是Derived)的构造函数,在这里同样要调用init(),执行程序判断出当前对象的实际类型是Derived,调用Derived::init()。

  3. delete pb; 无关紧要。

  例2(java的例子)的执行过程:

  1. Base base = new Derived();

  1) 分配内存。

  2) 调用基类(本例中是Base)的构造函数

  3) 在基类的构造函数中调用init(),执行程序首先判断出当前对象的实际类型是Derived(对,Derived已经构造出来,它的函数表当然也已经确定了)所以这里调用的是Derived::init()。

  4) 调用派生类(本例中是Derived)的构造函数,在这里同样要调用init(),执行程序判断出当前对象的实际类型是Derived,调用Derived::init()。

  明白了吧。java中的类对象在构造前(调用构造函数之前)就已经存在了,其函数表和对象类型也已经确定了,就是说还没有出生就已经存在了。而C++中只有在构造完毕后(所有的构造函数都被成功调用)才存在,其函数表和对象的实际类型才会确定。所以这两个例子的执行结果会不一样。当然,构造完毕后,C++与java的表现就都一样了,例如你调用Derived::do_init()的话,其执行结果是:

  1.   in Derived::init() 

  个人认为,java中的多态实现机制没有C++中的好。还是以例子说明吧:

  例子3:C++

  1.   class Base  
  2.   {  
  3.   public:  
  4.   Base()  
  5.   {  
  6.   init();  
  7.   }  
  8.   virtual ~Base() {}  
  9.   protected:  
  10.   int value;  
  11.   virtual void init()  
  12.   {  
  13.   value = 100;  
  14.   }  
  15.   };  
  16.   class Derived : public Base  
  17.   {  
  18.   public:  
  19.   Derived()  
  20.   {  
  21.   init();  
  22.   }  
  23.   protected:  
  24.   void init()  
  25.   {  
  26.   cout << "value = " << value << endl;  
  27.   // 做一些额外的初始化工作  
  28.   }  
  29.   };  
  30.   int main(int argc, char* argv[])  
  31.   {  
  32.   Base* pb;  
  33.   pb = new Derived();  
  34.   delete pb;  
  35.   return 0;  
  36.   } 

  例4:java

  1.   class Base   
  2.   {   
  3.   public Base()   
  4.   {   
  5.   init();   
  6.   }   
  7.   protected int value;   
  8.   protected void init()   
  9.   {   
  10.   value = 100;   
  11.   }   
  12.   }   
  13.   class Derived extends Base   
  14.   {   
  15.   public Derived()   
  16.   {   
  17.   init();   
  18.   }   
  19.   protected void init()   
  20.   {   
  21.   System.out.println("value = " + value);   
  22.   // 做一些额外的初始化工作   
  23.   }   
  24.   }   
  25.   public class Test   
  26.   {   
  27.   public static void main(String[] args)   
  28.   {   
  29.   Base base = new Derived();   
  30.   }   
  31.   }  

  例3的执行结果是:

  1.   value = 10 

  例4的执行结果是:

  1.   value = 0 
  2.   value = 0 

  从以上结果可以看出,java例子中应该被初始化的值(这里是value)没有被初始化,派生类根本不能重用基类的初始化函数。试问,如果初始化要在构造时完成,并且初始化逻辑比较复杂,派生类也需要额外的初始化,派生类是不是需要重新实现基类的初始化函数呢?这样的面向对象方法好不好呢?欢迎大家讨论。

【编辑推荐】

  1. 实例演示C++多态的实现过程
  2. C++多态实现方法探讨
  3. C++多态性基本概念讲述
  4. 深入理解Java多态性
  5. 对Java程序多态性支持的改进
  6. 深入Java核心 Java中多态的实现机制
责任编辑:韩亚珊 来源: 天极网开发频道
相关推荐

2011-04-12 10:40:04

C++多态

2011-04-11 09:43:25

C++C

2011-06-21 15:00:07

JAVAC++

2011-07-15 00:47:13

C++多态

2011-12-25 15:35:05

ibmdwJavaC++

2024-04-29 07:48:04

C++FinalOverride

2010-01-28 14:38:36

C++和C#、Java

2022-07-01 11:56:54

C语言C++编程语言

2020-06-17 12:22:44

C覆盖重载

2010-02-03 10:50:33

C++多态

2010-01-08 16:52:57

C++和C#

2010-11-22 16:01:08

C++多态

2010-01-28 15:22:12

C++嵌套类

2024-04-22 13:22:00

虚函数象编程C++

2024-01-23 10:13:57

C++虚函数

2011-07-13 18:00:51

CC++VC

2024-06-28 10:04:09

2009-10-22 09:17:16

C++ CLR

2024-02-26 12:13:32

C++开发编程

2010-02-05 16:07:52

C++多态覆盖
点赞
收藏

51CTO技术栈公众号