结构体的字节数是如何运算的

#include <iostream>
using namespace std;
//结构体A
struct A
    {
      short num;               
      int math_grade;      
      float Chinese_grade;   
      double sum_grade;      
     }student1;
      
//结构体B  
struct B
    {
     short num;      
     short math_grade;        
     char Chinese_grade;   
     double sum_grade;        
    }student2;
   
//结构体C
struct C
    {
     short num;      
     double sum_grade;
     short math_grade;   
     char Chinese_grade;
    }student3;

//结构体D
struct D
{
int a;      
double b;  
char c[9];  
};   

void main()
{   
    cout<<"sizeof(A)="<<sizeof(A)<<endl;
    cout<<"sizeof(B)="<<sizeof(B)<<endl;
    cout<<"sizeof(C)="<<sizeof(C)<<endl;
    cout<<"sizeof(C)="<<sizeof(D)<<endl;
}
/*输出结果：sizeof(A)=24
     sizeof(B)=16
     sizeof(C)=24
     sizeof(D)=32
首先，对于32位系统来说，编译器在进行结构体大小计算时要遵循2个规则：
一、结构体变量中成员的偏移量必须是成员大小的整数倍（0被认为是任何数的整数倍）
二、结构体大小必须是所有成员大小的整数倍。
对于第一个结构体，
类型  大小  偏移量
short   2      0
int    4      2
float   4    4+2+2=8
double  8    12+4=16
size=8+16=24
对于第二个结构体，
类型  大小  偏移量
short   2      0
short   2      2
char    1    2+2=4
double  8    1+4+3=8
size=8+8=16
对于第三个结构体，
类型  大小  偏移量
short   2      0
double  8    2+6=8
short   2      16
char    1    2+16+18
这里，1+18=19，根据第二条规则，编译器会在19的基础上加5，使其变成24

struct D
{
int a;       // 4个字节  （0-3）
double b;    //8个字节   （8-15）
char c[9];   //9个字节   （16-24）        最后结构题的大小是8的倍数32  //

经典话：

结构体的总大小为结构体最宽基本类型成员大小的整数倍