C++ sizeof不完全总结

本文是我在复习c++时，遇到各种计算sizeof操作的不完全总结，由于个人水平有限，不一定保证所说的完全正确，欢迎大家交流。

sizeof 是C/C++的一个操作符，它的作用是返回一个对象或类型所占的内存的字节数。

MSDN上的解释为：

  The sizeof keyword gives the amount ofstorage, in bytes, associated with avariable or a type(including aggregatetypes). This keyword returns a value of type size_t.

 

其返回值类型为size_t，在头文件stddef.h中定义。这是一个依赖于编译系统的值，一般定义为

typedef unsigned int size_t;

sizeof有三种语法形式，如下：

sizeof(object);//sizeof(对象);

sizeof(type_name);//sizeof(类型);

sizeofobject;//sizeof对象;

1.    作用于基本类型时

当sizeof作用于基本类型时，基本类型变量所占的内存大小和基本类型所占的大小一样，如下面代码所示。

#include <iostream>using namespace std;int main(){    char a;    bool b;    short c;    int d;    float f;    double db;    cout<<"sizeof(a): "<<sizeof(a);    cout<<" , sizeof(char) :"<<sizeof(char)<<endl;    cout<<"sizeof(b): "<<sizeof(b);    cout<<" , sizeof(bool) :"<<sizeof(bool)<<endl;    cout<<"sizeof(c): "<<sizeof(c);    cout<<" , sizeof(short) :"<<sizeof(short)<<endl;    cout<<"sizeof(d): "<<sizeof(d);    cout<<" , sizeof(int) :"<<sizeof(int)<<endl;    cout<<"sizeof(f): "<<sizeof(f);    cout<<" , sizeof(float) :"<<sizeof(float)<<endl;    cout<<"sizeof(db): "<<sizeof(db);    cout<<" , sizeof(double) :"<<sizeof(double)<<endl;    }

运行结果如下：

2.    当用于数组，指针时

当sizeof用于数组时，数组所占的内存为数组中每个元素所占的内存 *数组中元素的数目。当数组作为函数形参时，又有所不同。

#include <iostream>using namespace std;int main(){    char arr[10];    int aa[10];    double db[10];    cout<<"sizeof(char arr[10]) : "<<sizeof(arr)<<endl; //10    cout<<"sizeof(int aa[10]) : "<<sizeof(aa)<<endl;   //40    cout<<"sizeof(double db[10]): "<<sizeof(db)<<endl; //80}

运行结果如下：

当sizeof运用指针p时，与作用于数组有些不同。指针是用来存储变量的地址的，在不同位的系统中，地址的寻址空间不一样，导致表示一个地址所需的位数也不同。

在32位系统中，一个地址占32位，即4个字节，而64位系统中需要8个字节。所以在32位系统中，指针所占的内存空间为4个字节。以下实验是在32位系统下完成的。

#include <iostream>using namespace std;int main(){    char ca;    char carr[6];    char *pc = &ca;    char *pcc = carr;    cout<<"sizeof(pc) : "<<sizeof(pc)<<endl;     //4, not 1    cout<<"sizeof(pcc) : "<<sizeof(pcc)<<endl;   //4, not 6    cout<<"sizeof(*pc) : "<<sizeof(*pc)<<endl;   //1    cout<<"sizeof(*pcc) : "<<sizeof(*pcc)<<endl; //1    cout<<"sizeof(\"hello\") : "<<sizeof("hello")<<endl; //6, include '\0'    int ia;    int iarr[5];    int *pi = &ia;    int *pii = iarr;    cout<<"sizeof(pi) : "<<sizeof(pi)<<endl;  //4    cout<<"sizeof(pii) : "<<sizeof(pii)<<endl; //4    cout<<"sizeof(*pi) : "<<sizeof(*pi)<<endl; //4    cout<<"sizeof(*pii) : "<<sizeof(*pii)<<endl; //4    double da;    double drr[2];    double *pd = &da;    double *pdd = drr;    cout<<"sizeof(pd) : "<<sizeof(pd)<<endl;   //4    cout<<"sizeof(pdd) : "<<sizeof(pdd)<<endl;  //4    cout<<"sizeof(*pd) : "<<sizeof(*pd)<<endl;  //8    cout<<"sizeof(*pdd) : "<<sizeof(*pdd)<<endl;  //8}

运行结果如下：

当数组作为函数形参时，传递过去的并不是数组本身，而是数组的地址，这在计算sizeof时，发生了一些令人诧异的现象。

#include <iostream>using namespace std;int cal(char arr[]){    return sizeof(arr);}int main(){    char arr[10];    cout<<sizeof(arr)<<endl; //10    cout<<cal(arr)<<endl;//4, not 10}

运行结果如下：

从结果可以看出，在cal函数中，传递的参数实际上是数组的地址。

3. Sizeof用于复合结构

Sizeof用于string时

string并没有规定实施的标准，和编译器有关，它输出的是string对象或类所占的内存大小，不同编译器的结果不一样，有的返回4,16,32。

#include <iostream>#include <string>using namespace std;int main(){    string str;    cout<<"sizeof(str) : "<<sizeof(str)<<endl;              //32, @vs2010    string str2 = "hello world!";    cout<<"sizeof(str2) : "<<sizeof(str2)<<endl;            //32    string str3 = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";    cout<<"sizeof(str3) : "<<sizeof(str3)<<endl;            //32    cout<<"sizeof(str3.c_str()) : "<<sizeof(str3.c_str())<<endl;  //4}

运行结果如下：

Sizeof用于结构体

Sizeof用于结构体时，返回值为结构体中每一个成员变量所占的内存之和，如果一个结构体为空，那么它所占的内存为1个字节。但需要注意的是，在结构体中，需要注意内存对齐的问题。

 

一、内存对齐的原因

大部分的参考资料都是如是说的：

1、平台原因(移植原因)：不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常。

2、性能原因：数据结构(尤其是栈)应该尽可能地在自然边界上对齐。原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访问。

二、对齐规则

每个特定平台上的编译器都有自己的默认“对齐系数”(也叫对齐模数)。程序员可以通过预编译命令#pragma pack(n)，n=1,2,4,8,16来改变这一系数，其中的n就是你要指定的“对齐系数”。

 

对齐步骤：

1、数据成员对齐规则：结构(struct)(或联合(union))的数据成员，第一个数据成员放在offset为0的地方，以后每个数据成员的对齐按照#pragma pack指定的数值和这个数据成员自身长度中，比较小的那个进行。

2、结构(或联合)的整体对齐规则：在数据成员完成各自对齐之后，结构(或联合)本身也要进行对齐，对齐将按照#pragma pack指定的数值和结构(或联合)最大数据成员长度中，比较小的那个进行。

3、结合1、2颗推断：当#pragma pack的n值等于或超过所有数据成员长度的时候，这个n值的大小将不产生任何效果。

备注：数组成员按长度按数组类型长度计算，如char t[9],在第1步中数据自身长度按1算，累加结构体时长度为9;第2步中，找最大数据长度时，如果结构体T有复杂类型成员A的，该A成员的长度为该复杂类型成员A的最大成员长度。

 

当不使用#pragmapack时

#include <iostream>#include <string>using namespace std;struct A{};struct B{    char c;  //1,char以1为对齐系数，所以 offset[0,3]，包括填充字节    int a;   //4,int以4为对齐系数，所以 offset[4,7]    short b; //2,short以2为对齐系数，所以 offset[8,15]    double d; //8, double 以8为对齐系数，所以offset[16,23]    //结构整体以double的大小(8个字节)为对齐依据，所以b占8个字节    //其中2个是自身数据，后面6个字节是填充的    //整个size为 8+8+8 = 24 字节    //如果没有d,则整体按int的大小对齐，共占(4+4+4)=12字节};struct C{    char c;  //1, char以1为对齐系数，所以offset[0,1]    short b; //2, short以2为对齐系数，所以offset[2,3]    int a;   //4, int以4为对齐系数，所以offset[4,7]    double d; //8, double以8无对齐系数，所以offset[8,15]    //整体的size为 8(c,b,a)+8(d) = 16字节    //如果没有d,则整体按int的大小对齐，共占(2+2+4)=8字节  };struct D{    char arr[6];  //虽然是6个字符的数组，但以char大小对齐    char temp;     //整个大小为 6+1 = 7 字节};int main(){    cout<<sizeof(A)<<endl; //1    cout<<sizeof(B)<<endl; //24    cout<<sizeof(C)<<endl; //16    cout<<sizeof(D)<<endl; //7}

运行结果如下：

从B与C的对比中，我们可以发现，同样的数据，对齐方式不同，所占的内存大小也不一样。这对我们以后自己写程序有很大启示。

 

现在改变一下，以#pragma pack指定对齐大小

当使用#pragma pack(1)时

#include <iostream>#include <string>using namespace std;#pragma pack(1)struct A{};struct B{    char c;      int a;       short b;     double d;     // 1+4+2+8 = 15字节};struct C{    char c;      short b;     int a;       double d;     // 1+2+4+8 = 15字节};struct D{    char arr[6];      char temp;     //6+1= 7字节};int main(){    cout<<sizeof(A)<<endl; // 1    cout<<sizeof(B)<<endl; //15    cout<<sizeof(C)<<endl; //15    cout<<sizeof(D)<<endl;  //7}

运行结果如下：

当使用#pragma pack(2)时

#include <iostream>#include <string>using namespace std;#pragma pack(2)struct A{};struct B{    char c;  //offset[0,1]    int a;   //ofset[2,5]    short b; //ofset[6,7]    double d; //offset[8,15]    // 2+4+2+8 = 16字节};struct C{    char c;  //offset[0,1]    short b; //offset[2,3]    int a;   //offset[4,7]    double d; //offset[8,15]    // 2+2+4+8 = 16字节};struct D{    char arr[6];  //offset[0,5]    char temp;  //offset[6,6]    //6+1= 7字节 ,对齐系数为pragma参数和最大成员二者中的较小值};int main(){    cout<<sizeof(A)<<endl; // 1    cout<<sizeof(B)<<endl; //16    cout<<sizeof(C)<<endl; //16    cout<<sizeof(D)<<endl;  //7}

运行结果如下：

当使用#pragma pack(4)时

#include <iostream>#include <string>using namespace std;#pragma pack(4)struct A{};struct B{    char c;  //offset[0,3]    int a;   //ofset[4,7]    short b; //ofset[8,11]    double d; //offset[12,19]    // 4+4+4+8 = 20字节};struct C{    char c;  //offset[0,1]    short b; //offset[2,3]    int a;   //offset[4,7]    double d; //offset[8,15]    // 2+2+4+8 = 16字节};struct D{    char arr[6];  //offset[0,5]    char temp;  //offset[6,6]    //6+1= 7字节 ,对齐系数为pragma参数和最大成员二者中的较小值};int main(){    cout<<sizeof(A)<<endl; // 1    cout<<sizeof(B)<<endl; //20    cout<<sizeof(C)<<endl; //16    cout<<sizeof(D)<<endl;  //7}

运行结果如下：

当结构体的成员中含有结构体时

当一个结构体A包含另一个结构体B时，计算A所占用的内存空间时，需要先将B中的每个成员展开来，然后再确定对齐系数，但在后面计算时，需要将B看成一个整体，具体例子见下面程序。

#include <iostream>#include <string>using namespace std;struct S1{    char a;  //1    int b;  //4    //size = 4+4 = 8字节};struct S2{    short sh;  //offset[0,1]    char cc;  //offset[2,3]    S1 s;     //offset[4,11]    //S2在考虑时对齐系数时，是把S1展开，然后再选择对齐系数    //所以对齐系数是 4    //但是在计算时 ，确需要将S1当成一个整体，所以    //size = 4+8 = 12字节};struct S3{    char a;    short b;    //size = 2+2 = 4字节};struct S4{    int aa;    //offset[0,3]    short bb;  //offset[4,7]    S3 s;      //offset[8,15]    double dd;  //offset[16,23]    //将S3展开考虑对齐系数，应为double比较大，所以对齐系数为8    //size = 4+4 + 8+ 8 = 24字节 };int main(){    cout<<"sizeof(S1): "<<sizeof(S1)<<endl;  //8    cout<<"sizeof(S2): "<<sizeof(S2)<<endl;  //12    cout<<"sizeof(S3): "<<sizeof(S3)<<endl;  //4    cout<<"sizeof(S4): "<<sizeof(S4)<<endl;  //24}

运行结果如下所示：

Sizeof用于union时

结构体在内存组织上是顺序式的，联合体则是重叠式，各成员共享一段内存，所以整个联合体的sizeof也就是每个成员sizeof的最大值。结构体的成员也可以是复合类型，这里，复合类型成员是被作为整体考虑的。

#include <iostream>#include <string>using namespace std;struct S1{    char a;  //1    short b;  //2    //size = 2+2 = 4字节};struct S2{    char arr[6];    // size = 6字节};union U{    char c; //1字节    S1 s1;  //4字节    S2 s2;  //6字节    //size = 6字节};int main(){    cout<<"sizeof(S1): "<<sizeof(S1)<<endl;  //4    cout<<"sizeof(S2): "<<sizeof(S2)<<endl;  //6    cout<<"sizeof(S3): "<<sizeof(U)<<endl;  //6}

运行结果如下：

4.Sizeof用于类时

当类和结构体只有除了访问方式之外，没有其他区别时，其计算内存方式和结构体类似，但当存在继承关系时，就有所不同了。

#include <iostream>#include <string>using namespace std;class A{private:    int a;  //offset[0,3]    short b; //offset[4,5]    char c;  //offset[6,7]};class B: public A{    double a;    int b;    char c;    //B占了24个字节，除了新的的16个字节之外，还有A的成员部分};class C{    char c;    short b;};class D:public C{    double d;    //d占16个字节，除了新增的8个字节外，还有C中的4个字节，填充到8个字节};int main(){    cout<<sizeof(A)<<endl; //8    cout<<sizeof(B)<<endl; //24    cout<<sizeof(C)<<endl; //4    cout<<sizeof(D)<<endl; //16}

运行结果如下：

当一个类中包含有static成员时，计算该类型对象所占用的内存空间时，不需要将static成员考虑进去，因为static成员是类共有的，并不是某一个对象所单独拥有的。

 

#include <iostream>#include <string>using namespace std;class A{private:    short b;    char c;    static int count;};int main(){    A aa;    cout<<sizeof(aa)<<endl; //4    cout<<sizeof(A)<<endl; //4}

运行结果如下：

当类中存在虚函数时

(C++ primer plus)编译器处理虚函数的方法是:给每个对象添加一个隐藏成员。隐藏成员中保存了一个函数地址数组的指针。这种数组成为虚函数表。

虚函数表中存储了为类对象进行声明的虚函数的地址。基类的对象包含一个指针，该指针指向基类中所有虚函数的地址表。

派生类对象将包含一个指向独立地址表的指针。如果派生类提供了虚函数的新定义，该虚函数表将保存新函数的地址；

如果派生类没有重新定义虚函数，该虚函数表将保存函数原始版本的地址。如果派生类定义了新的虚函数，则该函数的地址也将被添加到虚函数表中。

注意，无论类中包含的虚函数时1个还是10个，都只需要在对象中添加一个地址成员，只是表的大小不同而已。

 

下面这张图是 c++ primer plus 中的虚函数表示意图。

实例如下：

#include <iostream>#include <string>using namespace std;class A{private:    int a;    short b;public :    virtual void fun1();    virtual void fun2();    //基础数据占8个字节，虚函数表占4个字节    //一共12字节};class B:public A{    int d;    virtual void fun1();    virtual void fun2();    //A中数据占8个字节，新增数据占4个字节    //虚函数表占4个字节，一共 16字节};int main(){    cout<<sizeof(A)<<endl; //12    cout<<sizeof(B)<<endl; //16}

运行结果如下：

后续如果有新的内容会继续补充。