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）无关；

 

示例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”）；