结构体内存对齐

一.先看一下内存图

内存字节图

二. 内存对⻬的原则

1:数据成员对⻬规则:结构(struct)(或联合(union))的数据成员，第
一个数据成员放在offset为0的地方，以后每个数据成员存储的起始位置要
从该成员大小或者成员的子成员大小(只要该成员有子成员，比如说是数组，
结构体等)的整数倍开始(比如int为4字节,则要从4的整数倍地址开始存
储。 min(当前开始的位置mn)m=9n=4
9 10 11 12
2:结构体作为成员:如果一个结构里有某些结构体成员,则结构体成员要从
其内部最大元素大小的整数倍地址开始存储.(struct a里存有struct b,b
里有char,int ,double等元素,那b应该从8的整数倍开始存储.)
3:收尾工作:结构体的总大小,也就是sizeof的结果,.必须是其内部最大成员的整数倍.不足的要补⻬。

三.自定义结构体

1.结构体例1:

struct LGStruct1 {
    double a;   //8 [0~7]
    char b;      // 1 8是1的倍数 [8]
    int c;         //4 9不是4的倍数 往后偏移到4的倍数 12,[12 13 14 15]
    short d;    //2  16是2的倍数 [16 17]
/*
17不是 8的倍数(double a;   //8 [0~7])所以要往后偏移到24
*/
}struct1;

为什么要字节对齐

需要字节对齐的根本原因在于CPU访问数据的效率问题。例如，假设一个处理器总是从存储器中取出8个字节，则地址必须为8的倍数。如果我们能保证将所有的double类型数据的地址对齐成8的倍数，那么就可以用一个存储器操作来读或者写值了。否则，我们可能需要执行两次存储器访问，因为对象可能被分放在两个8字节存储块中。也就利用空间换取时间.

2.结构体例2:

struct LGStruct1 {
    double a;   //8 [0~7]
    char b;      // 1 8是1的倍数 [8]
    int c;         //4 9不是4的倍数 
    short d;    //2 
}struct1;

struct LGStruct2 {
   double a;   //8 
    int c;         //4 
    char b;      // 1 
    short d;    //2 
}struct2;
       
//打印
int main(int argc, char * argv[]) {
    NSString * appDelegateClassName;
    @autoreleasepool {
        // Setup code that might create autoreleased objects goes here.
        appDelegateClassName = NSStringFromClass([AppDelegate class]);
        NSLog(@"输出:%lu-%lu",sizeof(struct11),sizeof(struct21));
    }
    return UIApplicationMain(argc, argv, nil, appDelegateClassName);
}

2021-06-09 15:52:17.358548+0800 001-内存对齐原则[2484:476177] 输出:24-16

3.结构体例3:结构体中包含结构体

①.结构体中包含结构体

struct LGStruct2 {
   double a;   //8 [0~7]
}struct2;

struct LGStruct1 {
    char b;                //1 [0] 

  struct  LGStruct2 str;   //8
/*
str 之前推算出占用 1个字节
struct  LGStruct2 str 占用8个, 所以1+8 =9个;
最大的字节是LGStruct2 double a,8个字节,所以必须是它的倍数,总共占用16个字节.
*/
}struct1;

//打印
        NSLog(@"输出:%lu-%lu",sizeof(struct1),sizeof(struct2));
输出:16-8

②.结构体中包含结构体

struct LGStruct2 {
    char b;                //1 
}struct2;

struct LGStruct1 {
   double a;   //8 [0~7]
  struct  LGStruct2 str;   //1 
/*
str 之前推算出占用 8个字节
struct  LGStruct2 str 占用1个, 所以1+8 =9个;
最大的字节是LGStruct1 double a,8个字节,所以必须是它的倍数,总共占用16个字节.
*/
}struct1;

//打印
        NSLog(@"输出:%lu-%lu",sizeof(struct1),sizeof(struct2));
输出:16-1

③.结构体中包含结构体

struct LGStruct2 {
   double a;   //8 [0~7]
}struct2;

struct LGStruct1 {
   double a;   //8 [0~7]
  struct  LGStruct2 str;   //8 
/*
str 之前推算出占用 8个字节
struct  LGStruct2 str 占用8个, 所以8+8 =16个;
最大的字节是LGStruct1 double a,8个字节,所以必须是它的倍数,总共占用16个字节.
*/
}struct1;
//打印
        NSLog(@"输出:%lu-%lu",sizeof(struct1),sizeof(struct2));
输出:16-8

④.结构体中包含结构体

struct LGStruct1 {
    double a; //8 [0~7]
    char b; // 1 [8]
    int c;  //4 (9 10 11 [12 13 14 15]
    short d; //2 [16 17] 24
}struct1;

struct LGStruct3 {
    double a;   //8 [0~7]
    int b;      //4 [8 9 10 11 12]
    char c;     //1 [13]
    short d;    //2 [14 15]
    int e;      //4 [16 17 18 19 20] 24
    struct LGStruct1 str; //[24]
/*
str 之前推算出占用 24个字节
struct  LGStruct2 str 占用24个, 所以24+24 =48个;
最大的字节是LGStruct3 double a和LGStruct1 double a都是8个字节,所以总共占用48个字节.
*/
}struct3;

//打印
        NSLog(@"输出:%lu-%lu",sizeof(struct3),sizeof(struct1));
输出:48-24

未完待续