这篇博客详细的介绍结构体的大小sizeof：union、struct、class。

一、不同数据类型所占的内存大小：

char  1
short 2
int   4
long 4
long long 8
double  8
float 4

二、union联合体的结构体大小 1、关注点： （1）联合体的大小为所有成员变量中所占字节数最大的； （2）当联合体中有数组时，一方面要保证空间能够存储这个数组的大小，另一方面要保证最终的结果是最大数据类型的整数倍。 2、示例（不同的情况） 示例①

union A {       //所占内存大小
    double a;   //8
    int b;      //4
    char c;     //1
};
//按照联合体的计算规则：sizeof（A）=8

示例②

union B {       //所占内存大小
    char s[9];    //9
    int b;        //4
    double c;     //8
};
//按照联合体的计算规则：sizeof（B）=16

示例③

union B {       //所占内存大小
    long f;     //4
    char b[3];  //3
    char c;     //1
};
//按照联合体的计算规则：sizeof（B）=4

示例④

union B {       //所占内存大小
    long f;      //4
    char b[5];   //5
    char c;      //1
    int c[7];     //28
};
按照联合体的计算规则：sizeof（B）= 28

三、struct结构体的大小 1、关注点： （1）struct的大小为最后一个成员的偏移量加上最后一个成员的大小，并且最终的结果要是所有数据成员大小的最小倍数； （2）第一个成员的偏移量为0。 \qquad第二个成员的偏移量=第一个成员的偏移量+第一个成员的大小。 （3）若struct中有数组，最终结构体的大小是按数组的数据类型的整数倍，而不是看整个数组。

2、示例（不同的情况） 示例①

struct A {       //偏移量
    double a;    //0
    int b;       //0+8=8
    char c;      //8+4=12
};
最终结构体的大小：sizeof(A)=12+1=13->16
变为16的原因：因为13不是int(4)、double(8) 的整数倍，所以最终的结果是16.

示例②

struct A {          //偏移量
    char a[9];      //0
    int b;          //0+9=9->12(因为9不是int（4）的整数倍，所以变为12)
    double c;       //12+4=16
};
最终结构体的大小：sizeof(A)=16+8=24

示例③

struct A {          //偏移量
    long a;      //0
    char b[3];   //0+4=4   所以变为12)
    char c;      //4+3=7
};
最终结构体的大小：sizeof(A)=7+1=8

示例④

struct A {          //偏移量
    long a;         //0
    char b[5];      //0+4=4    
    char c;         //4+5=9
    int z[7];       //9+1=10->12 (因为10不是int（4）的整数倍，所以变为12)
};
最终结构体的大小：sizeof(A)=12+28=40

四、struct嵌套，计算大小 1、关注点： （1）需要展开计算； （2）嵌套里面的结构体： \qquad展开后的求得的第一个的偏移量=嵌套结构体中所有元素的最小整数倍。 \qquad接下来就按照三中的方法计算。 （3）嵌套结构体的大小是所有成员的最小整数倍，这里的所有成员是展开后的单个数据元素的整数倍，而不是将嵌套的结构体看成一个整体。

2、示例（不同的情况） 示例①

struct A {          //偏移量
    short a;         //0
    struct S {   
        char c;      //0+2=2->4 (因为2不是int（4）的整数倍，所以变为4）
        int j;       //4+1=5->8
    }s;
    double k;       //8+4=12->16
};

最终结构体的大小：sizeof(A)=16+8=24

示例②

struct A {          //偏移量
    struct S {   
        char c;      //0
        int j;       //0+1=1->4
    }s;
    double k;       //4+4=8
};

最终结构体的大小：sizeof(A)=8+8=16

示例③

struct A {          //偏移量
    double i;       //0
    short m;        //0+8=8
    struct S {   
        char c;      //8+2=10->12
        char j;       //12+1=13
        int w;        //13+1=14->16
    }s;
    char a;           //16+4=20
    char b;           //20+1=21
    char d;           //21+1=22
    char e;           //22+1=23
    char f;           //23+1=24
};

最终结构体的大小：sizeof(A)=24+1=25->32 (8的倍数)

示例④

struct A {          //偏移量
    struct S {   
        char c;      //0
        char j;       //0+1=1
        int w;        //1+1=2->4
    }s;
    char a;           //4+4=8
    char b;           //8+1=9
    char d;           //9+1=10
    char e;           //10+1=11
    char f;           //11+1=12
};

最终结构体的大小：sizeof(A)=12+1=13->16 (4的倍数)

—— 本文来自火龙信奥（义乌睿码科技）：义乌青少年信息学奥赛与编程教育平台，专注 CSP-J/S、NOIP、GESP 竞赛培训，线上线下融合教学，助力编程升学。网址：hlcoding.com