sizeof终极解密

sizeof，在很多招聘笔试或者面试都会提到，它里面到底隐藏着多少陷阱呢？就让我们一探究竟。

铭记一个宗旨：sizeof计算的是一种数据类型（可以是结构体、int 、char、类等）所占的内存大小，只与类型有关，我们时刻关注的点应该是变量本身的类型，而不是它的值或指向的内存。

注：sizeof是运算符，不是函数。

一般可以这样理解：

数组——编译时分配的数组空间大小；
指针——存储该指针所用的空间大小（存储该指针的地址的长度，是长整型，应该为4）；
对象——对象的实际占用空间大小；
函数——函数的返回类型所占的空间大小。函数的返回类型不能是void；

本质上都可以理解为：

“类型”——该“类型”所占的空间大小。

示例1：计算一般类型数组指针

#include<stdio.h>int main(){    char arr[10]="What?";    char *parr=arr;    char *pchar=NULL;    int a[10];    int *pa=a;    int *pint;    printf("sizeof(arr)=%d\n",sizeof(arr));//10    printf("sizeof(parr)=%d\n",sizeof(parr));//4    printf("sizeof(*parr)=%d\n",sizeof(*parr));//1    printf("sizeof(pchar)=%d\n",sizeof(pchar));//4    printf("sizeof(*pchar)=%d\n\n",sizeof(*pchar));//1    printf("sizeof(a)=%d\n",sizeof(a));//40    printf("sizeof(pa)=%d\n",sizeof(pa));//4    printf("sizeof(*pa)=%d\n",sizeof(*pa));//4    printf("sizeof(pint)=%d\n",sizeof(pint));//4    printf("sizeof(*pint)=%d\n\n",sizeof(*pint));//4    return 0;}

运行结果如下：

解析如下：

sizeof(arr)=10; //其计算的类型为 sizeof(char*[10])  char乘以10，所以为10；

sizeof(parr)=4;//其计算的类型为sizeof(char *) 是一个指针类型，指针的存储用的是长整型，所以为4；

sizeof(*parr)=1;//其计算的类型为sizeof(char) 是一个字符型，所以为1；

注：与其值是多少（或指针指向什么，如NULL）无关；

示例2：计算函数

注:此处用于sizeof计算函数的函数名必须完整，就如同函数调用一般（但不真会调用该函数），并且函数的返回类型不能为void。

#include<stdio.h>char func1(int a){    printf("hello\n");    return 1;}int func2(int a){    printf("hello\n");    return 1;}int main(){    /*注:此处用于sizeof计算函数的函数名必须完整,就如同函数调用一般，并且函数的返回类型不能为void*/    printf("sizeof(func1)=%d\n",sizeof(func1(1)));    printf("sizeof(func2)=%d\n",sizeof(func2(1)));    return 0;}

运行结果如下：

解析：

sizeof(func1(1)):计算的是sizeof(char);

sizeof(func2(1)):计算的是sizeof(int);

示例3：计算复合类型（结构体、枚举等）

#include<stdio.h>//结构体typedef struct TESTstruct{    char a;    short b;    int c;}TESTstruct;//枚举typedef enum{    a=0,    b,    c}TESTenum;//共用体typedef union{    char a;    short b;    int c;}TESTunion;int main(){    //把复合类型看成int等之类的普通类型对待即可    TESTstruct tmpstruct1;    TESTstruct *tmpstruct2;    TESTenum tmpenum1;    TESTenum *tmpenum2;    TESTunion tmpunion1;    TESTunion *tmpunion2;    printf("sizeof(tmpstruct1)=%d\n",sizeof(tmpstruct1));//8    printf("sizeof(tmpstruct2)=%d\n",sizeof(tmpstruct2));//4    printf("sizeof(*tmpstruct2)=%d\n\n",sizeof(*tmpstruct2));//8    //C99把枚举类型也作为整型数据（int）中的一种    printf("sizeof(tmpenum1)=%d\n",sizeof(tmpenum1));//4    printf("sizeof(tmpenum2)=%d\n",sizeof(tmpenum2));//4    printf("sizeof(*tmpenum2)=%d\n\n",sizeof(*tmpenum2));//4    printf("sizeof(tmpunion1)=%d\n",sizeof(tmpunion1));//4    printf("sizeof(tmpunion2)=%d\n",sizeof(tmpunion2));//4    printf("sizeof(*tmpunion2)=%d\n\n",sizeof(*tmpunion2));//4    return 0;}

运行结果如下：

注：

1、把复合类型看成int等之类的普通类型对待即可，解析过程同普通类型；

2、C99把枚举类型也作为整型数据（int）中的一种；

3、在联合体中取最大成员所占的内存；

示例4：对于动态内存

#include<stdio.h>#include<malloc.h>int main(){    void *p=malloc(sizeof(char)*10);    void *pint=malloc(sizeof(int)*10);    int *pint1=(int *)malloc(sizeof(int)*10);    printf("sizeof(*p)=%d\n",sizeof(*p));//1    printf("sizeof(p)=%d\n\n",sizeof(p));//4    printf("sizeof(*pint)=%d\n",sizeof(*pint));//1    printf("sizeof(pint)=%d\n\n",sizeof(pint));//4    printf("sizeof(*pint1)=%d\n",sizeof(*pint1));//4    printf("sizeof(pint1)=%d\n\n",sizeof(pint1));//4    printf("sizeof(malloc(n))=%d\n",sizeof(malloc(100)));//4    return 0;}

运行结果如下：

解析：

1、malloc函数返回的void *，为一指针，因此sizeof(malloc(n))=4；

2、sizeof(*p)=1可以理解为malloc默认都是以单字节为基本单位申请内存，因此返回的从存储的角度看等同于char *p（实际上并非等同），根据示例1的分析可知为1；

3、sizeof(*pint1)=4此时的分析完全跟示例1一致。

类型5：针对C++中对象

还是得铭记宗旨，sizeof计算的是一种数据类型所占的内存大小，只与类型有关。因为对象是类的实例化，因此计算对象的大小实则计算C++中class类的这一数据类型（姑且这么认为）所占的内存大小。

示例如下：

#include<iostream>using namespace std;//空类class A{};class B{private:    int b1;};class C{private:    int c1;    char c2;};class D{public:     D(){}     virtual ~D(){}private:     int d1;     char *d2;};class E{public:    E(){}    virtual ~E(){}private:    int a ;    char *p;    static int b;};class F:public E{public:    F(){}    ~F(){}private:    int c;};class G: public virtual E{public:    G(){}    ~G(){}private:    int c;};class H: public E{public:    H(){}    ~H(){}    virtual void GetValue(){}private:    int c;};class I: public virtual E{public:    I(){}    ~I(){}    virtual void GetValue(){}private:    int c;    int a;};int main(){    A a;    B b;    C c;    D d;    E e;    F f;    G g;    H h;    I i;    cout<<"sizeof(A)="<<sizeof(A)<<endl;//1    cout<<"sizeof(a)="<<sizeof(a)<<"\n"<<endl;    cout<<"sizeof(B)="<<sizeof(B)<<endl;//4    cout<<"sizeof(C)="<<sizeof(C)<<endl;//8    cout<<"sizeof(D)="<<sizeof(D)<<endl;//12    cout<<"sizeof(E)="<<sizeof(E)<<endl;//12    cout<<"sizeof(F)="<<sizeof(F)<<endl;//12+4    cout<<"sizeof(G)="<<sizeof(G)<<endl;//12+4+4    cout<<"sizeof(H)="<<sizeof(H)<<endl;//12+4    cout<<"sizeof(I)="<<sizeof(I)<<endl;//12+4+4+4    return 0;}

运行结果如下：

解析：

1、针对空类，编译器默认分配子一个字节；

2、计算类大小时符合内存对齐原则，可以类比于结构体；

3、当类含有虚函数时，那么类中就有一个被隐藏的成员变量信息：虚函数指针（4个字节），这个指针指向一个虚函数表，即使有多个虚函数， 虚函数表只有一个，因此只有一个虚函数指针；

4、当类中含有静态数据成员时，由于静态成员变量是在静态存储区分配空间的，它不属于类空间的一部分，因此类中的static成员变量不占据空间；

5、非虚继承派生类对象的存储空间 = 基类存储空间 + 派生类特有的非static数据成员的空间(如果派生类有虚函数且基类也有，则忽略派生类虚函数的计算)；

6、如果是虚继承的话，类对象的存储空间大小 = 基类的存储空间 + 派生类特有的非static数据成员的存储空间 + 虚继承（+4）（注：此时忽略派生类中的虚函数）；

习题解析：

typedef  union  

 {

long   i;   

int  k[5];   

char   c;

} DATE;//最大类型为int[5]，所以sizeof(DATE)=20;

typedef struct  data   

{   

int   cat; //0-3

DATE   cow; //4-23  

double   dog;//24-31

} too; //因此sizeof(too)=32;

C99标准规定：void返回类型的函数（void *除外，返回的是指针）、位域（bit-field）成员不能被计算sizeof值

即：

void func1();

sizeof(func1());//错误

typedef struct tmp

{

unsigned int f1:1;

unsigned int f2:5;

unsigned int f3:12;

}tmp;

tmp a;

sizeof(a.f1);//错误

附：

char str[]="hello world";
sizeof(str)=12;

此处由于并未确定数组大小，因此我们可以理解为此处计算的实为实际数组的大小，因此为12（别忘了还有“\0”）；