C++和java多态的区别

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

创新互联建站拥有十余年成都网站建设工作经验,为各大企业提供成都网站建设、成都做网站服务，对于网页设计、PC网站建设（电脑版网站建设）、成都APP应用开发、wap网站建设（手机版网站建设）、程序开发、网站优化（SEO优化）、微网站、域名与空间等，凭借多年来在互联网的打拼，我们在互联网网站建设行业积累了很多网站制作、网站设计、网络营销经验，集策划、开发、设计、营销、管理等网站化运作于一体，具备承接各种规模类型的网站建设项目的能力。

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

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

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

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

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

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

　　例1：C++

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

　　例2：java

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

　　例1的执行结果是：

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

　　例2的执行结果是：

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

　　看了结果后，你是马上顿悟呢抑或是处于疑惑中呢?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() 
    2.

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

　　例子3：C++

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

　　例4：java

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

　　例3的执行结果是：

 
 
 
    
  
  
  
  1. 　　value = 10 
    2.

　　例4的执行结果是：

 
 
 
    
  
  
  
  1. 　　value = 0 
    2. 
  
  
  
  2. 　　value = 0 
    3.

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

分享名称：C++和java多态的区别
链接分享：http://www.gawzjz.com/qtweb2/news41/9091.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

企业网站制作知识

各行业网站

网站改版　　 　光华村机房　　 　移动服务器托管　　 　成都活动策划　　 　酒柜书柜鞋柜定制　　 　商城网站　　 　重庆电商网站定制　　 　响应式网站设计　　 　成都画册设计公司　　 　成都网站制作　　 　重庆机房托管　　 　网站建设方案　　 　禾巨建站　　 　做网站设计　　 　重庆APP开发　　 　成都网站推广　　 　软文推广公司　　 　无边发光字　　 　成都服务器托管　　 　成都网站建设