内存大小
在工作中，或多或少都会接触到内存对齐这个概念，而内存对齐到底是什么呢，今天来探索一下这个神秘的东西。话不多说，我们先来看下对象在内存中的存储。
首先创建一个类：LGPerson，然后实例化对象:
// 创建类
@interface LGPerson : NSObject
@property (nonatomic, copy) NSString *name;
@property (nonatomic, copy) NSString *nickName;
@property (nonatomic, assign) int age;
@property (nonatomic, assign) float height;
@property (nonatomic, assign) char flag;
@end
并对其各个属性赋值：
#import "LGPerson.h"
#import <objc/runtime.h>
#import <malloc/malloc.h>
// 实例化并赋值：
LGPerson *person = [LGPerson alloc];
person.name = @"degulade";
person.nickName = @"DG";
person.age = 18;
person.height = 180.5;
person.flag = 'a';
查看他们在内存中的存储：
查看它们的内存大小：
NSLog(@"对象类型的内存大小--%lu",sizeof(person));
NSLog(@"对象至少需要的内存大小--%lu",class_getInstanceSize([person class]));
NSLog(@"系统分配的内存大小--%lu",malloc_size((__bridge const void *)(person)));
结果：
通过结果我们可以看到，对象需要的内存大小与系统实际分配的内存大小并不一样。下面我们先给出结论:
- 在 C 语言中，
sizeof()是一个判断数据类型或者表达式长度的运算符。sizeof()的计算发生在编译时刻，所以它可以被当作常量表达式使用.而sizeof(person)打印的是person的类型也就是对象，本质上他是结构体指针 -
class_getInstanceSize打印出的结果是对象至少需要的内存大小，在这里我们创建的DMPerson类一共有5个属性，其中2个NSString，1个int,1个float，1个char类型。再加上类本身isa需要的8个字节，因此DMPerson类至少需要8+8+8+4+4+1 = 33然后8字节对齐，因此打印输出是40。 -
malloc_size打印的结果是系统分配的实际内存大小，前面我们计算出LGPerson类至少需要40个字节才能完整的存储下来，而在内存中对类的实际分配是16字节对齐,因此最后结果是48。
内存对齐
通过上面的代码分析，我们了解不同的数据类型，在内存中占用的大小是不一样的，各种类型具体的内存占用大小如下：
举个例子：
struct LGStruct1 {
double a;
char b;
int c;
short d;
}struct1;
struct LGStruct2 {
double a;
int b;
char c;
short d;
}struct2;
NSLog(@"struct1内存大小：%lu,struct2内存大小：%lu",sizeof(struct1),sizeof(struct2));
创建如上两个结构体，包含了一样的数据元素，但是成员变量的位置不同，所以他们的sizeof(内存大小)是否是一样呢?
打印出结果：
结果我们可以看到，两个内容完全相同的结构体，因为成员变量位置的不同，最后sizeof出来的结果不一样。但是这是为什么呢，因为内存对齐,需要遵守内容对齐原则。
内存对齐原则
数据成员对⻬规则：结构(struct)(或联合(union))的数据成员，第⼀个数据成员放在offset为0的地⽅，以后每个数据成员存储的起始位置要从该成员⼤⼩或者成员的⼦成员⼤⼩（只要该成员有⼦成员，⽐如说是数组，结构体等）的整数倍开始(⽐如int为４字节,则要从４的整数倍地址开始存储。 min(当前开始的位置m n) m = 9 n = 4，n：[9 10 11 12]结构体作为成员：如果⼀个结构⾥有某些结构体成员，则结构体成员要从其内部最⼤元素⼤⼩的整数倍地址开始存储(struct a⾥存有struct b,b⾥有char,int ,double等元素,那b应该从8的整数倍开始存储)收尾⼯作：结构体的总⼤⼩，也就是sizeof的结果，必须是其内部最⼤成员的整数倍，不⾜的要补⻬。
结构体对齐
以上面的结构体struct1和struct2为例，根据内存对齐原则，我们就可以知道他们的数据存储规则了：
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 LGStruct2 {
double a; // 8 [0 7]
int b; // 4 [8 9 10 11]
char c; // 1 [12]
short d; // 2 (13 [14 15] 【16】
}struct2;
为了更加清晰，我们用图文形式表现出来：
首先，元素a为double，占用字节为8[0 7]；元素b为char，占用字节为1[8]；元素c为int，占用字节4(9 10 11) [12 13 14 15]；元素d为short，占用字节2[16 17]；根据对齐原则的收尾要求：必须是内部最大成员（a：8）的整数倍，又因为2*8 < d的字节大小，所以LGStruct1等于（3*8）24字节。
前面的元素略过，最后所占字节数为16，根据内存对齐原则的收尾要求，16字节为其内部最大成员double a所占空间8字节的整数倍，所以等于16字节。
再结合之前的打印结果，证明了系统确实是按照这个原则进行的数据存储。
结构体对齐（结构体嵌套）
举个例子：
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 LGStruct2 {
double a; // 8 [0 7]
int b; // 4 [8 9 10 11]
char c; // 1 [12]
short d; // 2 (13 [14 15] 【16】
}struct2;
// 家庭作业 : 结构体内存对齐
struct LGStruct3 {
double a; // 8 [0...7]
int b; // 4 [8 9 10 11]
char c; // 1 [12]
short d; // 2 (13 [14 15]
int e; // 4 (16 [17 18 19 20] 【 24】
struct LGStruct1 str1; // 【24】 + 24
struct LGStruct2 str2; // 【16】 + 48
}struct3;
NSLog(@"struct3内存大小：%lu",sizeof(struct3));
我们首先看看系统计算的结果：
根据对齐原则，如图所示：
由于struct LGStruct1 str也是一个结构体，因此其内部也需要进行字节对齐，str1所占的字节数是24字节，按照内存对齐原则的第二条，str需要从24的位置开始存储占用24个字节，占用字节数为48字节。最后的struct LGStruct2 str2，，str2所占的字节数是16字节，从48字节开始，占用为64字节；且满足第三条原则，所以最终占用字节数为（8*8）64字节。
总结以上经验，我们可以得出结论：结构体中的结构体，也是以整体的形式进行存储的，其内部也需要进行内存对齐。
至此，我们可以得出对于结构体，系统确实是按照内存对齐原则来进行存储数据的。
在iOS中，对象的本质实际上就是结构体，是不是能用结构体内存对齐的理论来验证呢，我们继续往下探索：
内存优化
我们修改一下最初LGPerson类的代码，修改它的属性的位置：
@interface LGPerson : NSObject
@property (nonatomic, copy) NSString *nickName;
@property (nonatomic, copy) NSString *name;
@property (nonatomic, assign) float height;
@property (nonatomic, assign) char flag;
@property (nonatomic, assign) int age;
赋的值不变，然后打印内存地址：
输出结果：
实际上系统在对象层面已经对内存对齐进行了优化，不管你属性是怎么样排列的，系统都会按照最优的顺序，将数据存储到内存中去。
总结
系统的数据存储都是根据内存对齐原则来进行对齐的，对于结构体，可能会因为成员顺序的问题，造成一定的内存空间浪费，而对于对象来说，在iOS的系统层面已经帮我们进行了内存优化，保证了最优的存储方式。因此，在开发过程中，如果使用到了结构体类型，需要特别注意内存对齐的相关问题。
