C++中的类所占内存空间总结

Posted 2022-12-09 zhanghuan_wangkai

类所占内存的大小是由成员变量（静态变量除外）决定的，成员函数（这是笼统的说，后面会细说）是不计算在内的。

摘抄部分：

成员函数还是以一般的函数一样的存在。a.fun()是通过fun(a.this)来调用的。所谓成员函数只是在名义上是类里的。其实成员函数的大小不在类的对象里面，同一个类的多个对象共享函数代码。而我们访问类的成员函数是通过类里面的一个指针实现，而这个指针指向的是一个table，table里面记录的各个成员函数的地址（当然不同的编译可能略有不同的实现）。所以我们访问成员函数是间接获得地址的。所以这样也就增加了一定的时间开销，这也就是为什么我们提倡把一些简短的，调用频率高的函数声明为inline形式（内联函数）。

成员函数也是要占用空间的，只不过是多个对象公用一个成员函数的空间而已。

书上有这样一段话：
一个类可以创建多个对象
在创建对象时，编译系统只为对象中的成员数据（成员变量）分配内存空间
而同类对象的成员函数的代码却是共享的
…………
创建一个对象时，为该对象分配的存储空间为它的数据成员所占用的存储空间的总和

(一)
class CBase 
 
; 
sizeof(CBase)=1；

为什么空的什么都没有是1呢？
c++要求每个实例在内存中都有独一无二的地址。//注意这句话！！！！！！！！！！
空类也会被实例化，所以编译器会给空类隐含的添加一个字节，这样空类实例化之后就有了独一无二的地址了。所以空类的sizeof为1。

(二)

class CBase 
 
int a; 
char p; 
; 
sizeof(CBase)=8;
记得对齐的问题。int 占4字节//注意这点和struct的对齐原则很像！！！！！
char占一字节，补齐3字节

(三)
class CBase 
 
public: 
CBase(void); 
virtual ~CBase(void); 
private: 
int  a; 
char *p; 
; 
再运行：sizeof(CBase)=12

C++ 类中有虚函数的时候有一个指向虚函数的指针（vptr），在32位系统分配指针大小为4字节。无论多少个虚函数，只有这一个指针，4字节。//注意一般的函数是没有这个指针的，而且也不占类的内存。

(四)
class CChild : public CBase 
 
public: 
CChild(void); 
~CChild(void); 

virtual void test();
private: 
int b; 
; 
输出：sizeof(CChild)=16；
可见子类的大小是本身成员变量的大小加上父类的大小。//其中有一部分是虚拟函数表的原因，一定要知道

父类子类共享一个虚函数指针

(五)

#include<iostream.h>

class a ;

class b;

class c:public a

virtual void fun()=0;

;

class d:public b,public c;

int main()

cout<<"sizeof(a)"<<sizeof(a)<<endl;

cout<<"sizeof(b)"<<sizeof(b)<<endl;

cout<<"sizeof(c)"<<sizeof(c)<<endl;

cout<<"sizeof(d)"<<sizeof(d)<<endl;

return 0;

程序执行的输出结果为：

sizeof(a) =1

sizeof(b)=1

sizeof(c)=4

sizeof(d)=8

前三种情况比较常见，注意第四种情况。类d的大小更让初学者疑惑吧，类d是由类b，c派生迩来的，它的大小应该为二者之和5，为什么却是8 呢？这是因为为了提高实例在内存中的存取效率．类的大小往往被调整到系统的整数倍．并采取就近的法则，里哪个最近的倍数，就是该类的大小，所以类d的大小为8个字节．

总结：

空的类是会占用内存空间的，而且大小是1，原因是C++要求每个实例在内存中都有独一无二的地址。

（一）类内部的成员变量：

• 普通的变量：是要占用内存的，但是要注意对齐原则（这点和struct类型很相似）。
• static修饰的静态变量：不占用内容，原因是编译器将其放在全局变量区。

（二）类内部的成员函数：

• 普通函数：不占用内存。
• 虚函数：要占用4个字节，用来指定虚函数的虚拟函数表的入口地址。所以一个类的虚函数所占用的地址是不变的，和虚函数的个数是没有关系的

昨天去面试一家公司，面试题中有一个题，自己没弄清楚，先记录如下：

[cpp]

  view plain  copy  

1. class D  
2.   
3. public:  
4.     void printA()  
5.       
6.         cout<<"printA"<<endl;  
7.       
8.     virtual void printB()  
9.       
10.         cout<<"printB"<<endl;  
11.       
12. ;  

main函数调用：

D *d=NULL;
d->printA();
d->printB();

输出结果是？

当时想的是对象d直接初始化为NULL，非虚的成员函数没有地址，应该找不到，而virtual成员函数，由于对象会有指向虚拟函数表的指针-vptr，指向virtual函数列表的虚拟函数表，这样应该能够取到地址（实际上，这个virtual函数的printB最应该想到是直接崩溃，因为d指向NULL，即地址为0x00000000,再去找虚地址指针，肯定是不允许的）。

下面具体分析一下吧

先看一下类的成员函数的情况，

[cpp]

  view plain  copy  

1. class A  
2.   
3.   
4. ;  
5. class B  
6. public:  
7.     B()  
8.     ~B()  
9. ;  
10. class C  
11.   
12. public:  
13.     C()  
14.     virtual ~C()  
15. ;  

类A、B、C三个类，一个是什么都没有的真的空类，一个是有成员函数的类，最后一个是带有虚函数的类。

那他们分别咱的内存大小是多少呢？

cout<<"A="<<sizeof(A)<<endl;
cout<<"B="<<sizeof(B)<<endl;
cout<<"C="<<sizeof(C)<<endl;

32位windows xp机器上测试结果：

A=1

B=1

C=4

从A和B的比较可以看出成员函数是不占用类空间的，再具体一个例子：

[cpp]

  view plain  copy  

1. class E  
2. public:  
3.     E()  
4.     ~E()  
5. private:  
6.     int m_data;  
7.     char c;  
8. ;  

sizeof(E)在32位机器上输出结果，如果不考虑对齐 为5，考虑则为8，可见和上面B类的预期一致。

    我们可以说，静态数据成员和静态成员函数时类的一部分，而不是对象的一部分（谭老师说的）。

当我们实例化一个对象的时候，因为这个对象是用类定义的，那么它理所当然拥有了这个类的数据和函数。但是，一般情况下，不同的对象，他们的的数据值不同，但是函数的代码都相同。所以，为了节约存储空间（想象一下我们如果定义了100个对象，那么用100段内存空间存储相同的代码，岂不是很浪费？），我们让成员函数的代码共享。

      我们把成员函数的代码存储在对象空间之外。换句话说，成员函数的代码，都不占据对象的存储空间。它会被存在其他地方。

      所以类的成员函数，对于类来讲。一方面是逻辑上的“属于”，一方面是物理上的“不依赖“。

      回到思考题上来，对于非静态成员函数来说，它当然是对象的一部分。（只是因为存储方式上的特殊性，容易让人误解！）

回答开头问题：

类中包括成员变量和成员函数
new出来的只是成员变量，成员函数始终存在
所以如果成员函数未使用任何成员变量的话，不管是不是static的，都能正常工作

一个对象的空间=所有成员变量的大小
如果这个对象的类有虚函数的话，还可能多一个指向虚表的指针

所有函数存放在独立于对象的存储空间内
对象调用函数时，对静态成员函数直接调用不存在问题，对成员函数需要把自己以this指针传给函数以指明以哪个对象调用

所以用未初始化的指针调用静态成员函数、或者调用未使用任何成员变量的成员函数（即未用到this指针）
从理论上都是可行的，至于具体支不支持看各个编译器吧

思考：

main函数中，如果

D d;//=NULL;
    d.printA();
    d.printB();

调用呢？

都能正常输出，d在栈上。。。