C++虚函数解析(转载)

虚函数详解第一篇:对象内存模型浅析

C++中的虚函数的内部实现机制到底是怎样的呢?

鉴于涉及到的内容有点多,我将分三篇文章来介绍。

第一篇:对象内存模型浅析,这里我将对对象的内存模型进行简单的实验和总结。

第二篇:继承对象的构造和析构浅析,这里我将对存在继承关系的对象的构造和析构进行简单的实验和总结。

第三篇:虚函数的内部机制浅析,这里我将对虚函数内部的实现机制进行实验总结。

我使用的编译器是VS2008,有不足或者不准确的地方,欢迎大家拍砖(我个人非常迫切的希望得到大家的指正),我会及时修正相关内容。

开始正题:对象内存模型浅析:

  1. #include <tchar.h>
  2. #include <iostream>
  3. using namespace std;
  4. #pragma pack (1)
  5. class Person
  6. {
  7. private:
  8. int m_nAge;
  9. };
  10. class Man : public Person
  11. {
  12. private:
  13. double m_dHeight;
  14. };
  15. int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])
  16. {
  17. Person Jack;
  18. Man Mike;
  19. cout << sizeof(Jack) << endl;
  20. cout << sizeof(Mike) << endl;
  21. return 1;
  22. }

首先解释一下#pragma pack(1)这条语句的作用,它要求编译器将字节对齐的最小单位设定为1个字节。

关于字节对齐,简单的解释就是,假定一个32位的CPU,读取一个存储在内存中的int型的变量,如果该int变量存放在内存中的首地址是偶地址,那么CPU一个周期就能读出这32bit的数据,如果该int变量存放在内存中的首地址是奇地址,就需要2个读周期,并对两次读出的结果的高低字节进行拼凑才能得到该32bit数据。所以,如果我们将字节对齐设置为4个字节,那么理论上,CPU执行我们代码的速度要比将字节对齐设置为1个字节的速度要快。

所以,如果我们将字节对齐设置为8个字节,那么

int nNum1;

double dNum2;

将会占用16个字节的大小,而如果我们将字节对齐设置为1个字节,那么它将会占用12个字节的大小,上述代码将字节对齐设置为1个字节,是为了防止字节对齐干扰了我们对于对象内存模型的实验。

回到主题,上述代码的执行结果如下:

4

12

我们看到,Person类对象占用了4个字节大小的内存空间,Man类对象占用了12个字节的大小的内存空间,所以,Man类中实际上有两个成员变量,int m_nAge和double m_dHeight,所以可以得出一个结论:派生类对象中同时包含基类的成员变量。

那么它们在内存中的位置是怎样的呢?

  1. #include <tchar.h>
  2. #include <iostream>
  3. using namespace std;
  4. #pragma pack (1)
  5. class Person
  6. {
  7. private:
  8. int m_nAge;
  9. };
  10. class Man : public Person
  11. {
  12. private:
  13. double m_dHeight;
  14. };
  15. class Woman : public Person
  16. {
  17. private:
  18. double m_dWigth;
  19. };
  20. int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])
  21. {
  22. Person Jack;
  23. Man Mike;
  24. Woman Susan;
  25. cout << &Jack << endl;
  26. cout << &Mike << endl;
  27. cout << &Susan << endl;
  28. return 1;
  29. }

上述代码输出了Person类对象和Man类对象的地址,执行结果如下:

0012FF60

0012FF4C

0012FF38

我们知道,0012FF60和0012FF4C之间有14个字节的内存空间,0012FF38和0012FF4C之间有14个字节的内存空间,我们将Man类对象分成Person基类部分(int m_nAge)和Man派生类部分(double m_dHeight),将Woman类对象分成Person基类部分(int m_nAge)和Woman派生类部分(double m_dWeight)。那么,Man类和Woman类的对象内存模型如下:

所以,

  • Person Jack;
  • Man Mike;
  • Woman Susan;

这三行代码实际上产生了3个Person基类部分、一个Man派生类部分和一个Woman派生类部分,而非像代码中写的表意那样,有一个Person基类部分,一个Man派生类部分和一个Woman派生类部分。

类的继承和派生只是简化方便我们程序员编写代码,并不会简化派生类对象占用的内存大小。

虚函数详解第二篇:继承对象的构造和析构浅析

C++中的虚函数的内部实现机制到底是怎样的呢?

鉴于涉及到的内容有点多,我将分三篇文章来介绍。

第一篇:对象内存模型浅析,这里我将对对象的内存模型进行简单的实验和总结。

第二篇:继承对象的构造和析构浅析,这里我将对存在继承关系的对象的构造和析构进行简单的实验和总结。

第三篇:虚函数的内部机制浅析,这里我将对虚函数内部的实现机制进行实验总结。

我使用的编译器是VS2008,有不足或者不准确的地方,欢迎大家拍砖(我个人非常迫切的希望得到大家的指正),我会及时修正相关内容。

开始正题:继承对象的构造和析构浅析:

在虚函数详解第一篇中,我简单的介绍了C++对象内存模型。我们了解到派生类对象是由基类部分和派生部分构成的,那么该派生类对象是如何被构造和析构的呢?

  1. #include <tchar.h>
  2. #include <iostream>
  3. using namespace std;
  4. class Person
  5. {
  6. public:
  7. Person()
  8. {
  9. cout << _T("基类的构造函数被调用") << endl;
  10. }
  11. ~Person()
  12. {
  13. cout << _T("基类的析构函数被调用") << endl;
  14. }
  15. };
  16. class Man : public Person
  17. {
  18. public:
  19. Man()
  20. {
  21. cout << _T("派生类的构造函数被调用") << endl;
  22. }
  23. ~Man()
  24. {
  25. cout << _T("派生类的析构函数被调用") << endl;
  26. }
  27. };
  28. int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])
  29. {
  30. Man Mike;
  31. return 1;
  32. }

上述代码的执行结果如下:

我们可以看到:构造一个派生类对象的时候,先调用基类的构造函数,再调用派生类的构造函数,析构一个派生类对象的时候,先调用派生类的析构函数,再调用基类的析构函数。

上述内容讲述的是普通派生类的构造和析构过程,对于具有虚函数的派生类的构造和析构过程是怎样的呢?

  1. #include <tchar.h>
  2. #include <iostream>
  3. using namespace std;
  4. class Person
  5. {
  6. public:
  7. Person()
  8. {
  9. cout << _T("基类的构造函数被调用") << endl;
  10. }
  11. virtual void Height()
  12. {
  13. cout << _T("人类具有身高属性") << endl;
  14. }
  15. virtual ~Person()
  16. {
  17. cout << _T("基类的析构函数被调用") << endl;
  18. }
  19. };
  20. class Man : public Person
  21. {
  22. public:
  23. Man()
  24. {
  25. cout << _T("派生类的构造函数被调用") << endl;
  26. }
  27. virtual void Height()
  28. {
  29. cout << _T("男人具有身高属性") << endl;
  30. }
  31. virtual ~Man()
  32. {
  33. cout << _T("派生类的析构函数被调用") << endl;
  34. }
  35. private:
  36. double m_dHeight;
  37. double m_dWeight;
  38. };
  39. int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])
  40. {
  41. Person* pPersonObj = new Man;
  42. delete pPersonObj;
  43. return 1;
  44. }

上述代码的执行结果如下:

大家可能注意到了,上述代码中基类和派生类的析构函数都采用虚析构函数,而在_tmain函数中的调用方式也采用了Person* pPersonObj = new Man这种多态调用方式。当delete pPersonObj被执行来释放派生类对象的时候,实际上调用的是派生类对象的虚析构函数,而派生类对象的虚析构函数会调用基类的析构函数,这样就能将派生类对象完美的析构,如果这里不采用虚析构函数,会是什么结果呢?

  • #include <tchar.h>
  • #include <iostream>
  • using namespace std;
  • class Person
  • {
  • public:
  • Person()
  • {
  • cout << _T("基类的构造函数被调用") << endl;
  • }
  • virtual void Height()
  • {
  • cout << _T("人类具有身高属性") << endl;
  • }
  • ~Person()
  • {
  • cout << _T("基类的析构函数被调用") << endl;
  • }
  • };
  • class Man : public Person
  • {
  • public:
  • Man()
  • {
  • cout << _T("派生类的构造函数被调用") << endl;
  • }
  • virtual void Height()
  • {
  • cout << _T("男人具有身高属性") << endl;
  • }
  • virtual ~Man()
  • {
  • cout << _T("派生类的析构函数被调用") << endl;
  • }
  • private:
  • double m_dHeight;
  • double m_dWeight;
  • };
  • int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])
  • {
  • Person* pPersonObj = new Man;
  • delete pPersonObj;
  • return 1;
  • }

上述代码执行结果如下:

我们可以看到,当delete pPersonObj被执行的时候,只调用了基类的析构函数,并没有调用派生类的析构函数,所以这个对象的派生部分的内存并没有被释放,从而造成内存泄露。

所以:当基类中包含有虚函数的时候,析构函数一定要写成虚析构函数,否则会造成内存泄露。

为什么一定要这么做呢?我们在第三篇的内容里寻找答案。

第三篇:自己打算写,待续。。。

C++虚函数解析(转载),布布扣,bubuko.com

时间: 08-12

C++虚函数解析(转载)的相关文章

C++构造函数和析构函数能否声明为虚函数?(转载)

构造函数为什么不能是虚函数 从存储空间角度,虚函数对应一个指向vtable虚函数表的指针,这大家都知道,可是这个指向vtable的指针其实是存储在对象的内存空间的.问题出来了,如果构造函数是虚的,就需要通过 vtable来调用,可是对象还没有实例化,也就是内存空间还没有,怎么找vtable呢?所以构造函数不能是虚函数. 从使用角度,虚函数主要用于在信息不全的情况下,能使重载的函数得到对应的调用.构造函数本身就是要初始化实例,那使用虚函数也没有实际意义呀.所以构造函数没有必要是虚函数.虚函数的作用

构造函数为什么不能是虚函数 ( 转载自C/C++程序员之家)

从存储空间角度,虚函数对应一个指向vtable虚函数表的指针,这大家都知道,可是这个指向vtable的指针其实是存储在对象的内存空间的.问题出来了,如果构造函数是虚的,就需要通过 vtable来调用,可是对象还没有实例化,也就是内存空间还没有,怎么找vtable呢?所以构造函数不能是虚函数. 从使用角度,虚函数主要用于在信息不全的情况下,能使重载的函数得到对应的调用.构造函数本身就是要初始化实例,那使用虚函数也没有实际意义呀.所以构造函数没有必要是虚函数.虚函数的作用在于通过父类的指针或者引用来

C++中的虚函数解析[The explanation for virtual function of CPlusPlus]

1.什么是虚函数?                                                                                                                                               答:在C++的类中,使用virtual修饰的函数. 例如: virtual void speak() const { std::cout << "Mammal speak!\n&quo

虚函数(转载)

一般继承(无虚函数覆盖) 下面,再让我们来看看继承时的虚函数表是什么样的.假设有如下所示的一个继承关系: 请注意,在这个继承关系中,子类没有重载任何父类的函数.那么,在派生类的实例中,其虚函数表如下所示: 对于实例:Derive d; 的虚函数表如下: 我们可以看到下面几点: 1)虚函数按照其声明顺序放于表中. 2)父类的虚函数在子类的虚函数前面. 我相信聪明的你一定可以参考前面的那个程序,来编写一段程序来验证. 一般继承(有虚函数覆盖) 覆盖父类的虚函数是很显然的事情,不然,虚函数就变得毫无意

【转】C++虚函数解析

本文转自陈皓大叔(左耳朵耗子)的博客www.coolshell.com. 文章是很久之前所写,去年还在写C++时有幸拜读,现在想起来还是相当有价值一转的,如果有一定C++基础(特别是读过<深度探索C++对象模型>)应该可以比较无痛地理解这篇文章.另外十分打心底敬佩那些肯花大量时间和心血写这些高质量文章的前辈. ========================================================================================== C+

C++之虚函数和虚继承

首先来看一个实例 1 #include <iostream> 2 #include<stdio.h> 3 #include<stdlib.h> 4 #include<assert.h> 5 using namespace std; 6 class A 7 { 8 public: 9 A(){ cout << "A构造函数" << endl; } 10 ~A(){ cout << "A析构函数&

C++ 虚函数表解析(比较清楚,还可打印虚函数地址)

C++ 虚函数表解析 陈皓 http://blog.csdn.net/haoel 前言 C++中的虚函数的作用主要是实现了多态的机制.关于多态,简而言之就是用父类型别的指针指向其子类的实例,然后通过父类的指针调用实际子类的成员函数.这种技术可以让父类的指针有“多种形态”,这是一种泛型技术.所谓泛型技术,说白了就是试图使用不变的代码来实现可变的算法.比如:模板技术,RTTI技术,虚函数技术,要么是试图做到在编译时决议,要么试图做到运行时决议. 关于虚函数的使用方法,我在这里不做过多的阐述.大家可以

虚函数原理解析

虚函数原理 虚函数的一般实现模型:每个类有一个虚函数表,内含该类中有作用的虚函数地址.每个 对象有一个vptr(虚函数表指针)指向虚函数表 如下Person类 class Person { public: virtual ~Person(); virtual string& getName(); virtual string& setName(); protected: string name_; }; 在Person的对象Jack中,有两个东西,一个是数据成员name_,一个是_Vptr

【转载】 C++多继承中重写不同基类中相同原型的虚函数

本篇随笔为转载,原文地址:C++多继承中重写不同基类中相同原型的虚函数. 在C++多继承体系当中,在派生类中可以重写不同基类中的虚函数.下面就是一个例子: class CBaseA { public: virtual void TestA(); }; class CBaseB { public: virtual void TestB(); }; class CDerived : public CBaseA, public CBaseB { public: virtual void TestA()