本文主要讲解编译器的优化以及指针的汇编
编译器优化
设置
可在项目的BuildSetting->Optimization Level中找到，一般的优化方案选择FS（Fastest，Smallest）
案例分析
有以下代码
int main(int argc, char * argv[]) { int a = 1; int b = 2; }
在没有优化情况下的汇编如下
将优化方案从None改成FS，汇编如下
修改1：main中调用
int sum(int a, int b){ return a + b; } int main(int argc, char * argv[]) { sum(1, 2); }
查看此时是否有1，2，发现也没有sum有关的汇编代码，其优化原则是这样的：去掉sum对程序运行的结果没有影响【原则1：对结果没有任何影响的代码会被编译器优化】
修改2：打印sum的结果
int sum(int a, int b){ return a + b; } int main(int argc, char * argv[]) { int a = sum(1, 2); printf(@"%d", a); }
此时如果优化掉sum，对执行结果是有影响。可以发现sum函数被优化掉了，优化成了一个结果
指针
在OC中，无论参数还是返回值，如果传入/返回的是对象，这些对象都是指针，下面来看看指针的反汇编
void func(){ int *a; printf("%lu", sizeof(a)); //sizeof不是函数，是一个符号 } int main(int argc, char * argv[]) { func(); }
分析以上代码的汇编代码
指针常识
指针自增自减运算
void func(){ int *a; a = (int *)100; a++; printf("%d", a); } <!--打印结果--> 104
- 问题：a++之后，a是多少？
- 是104，因为
指针的自增自减和指向的数据类型宽度有关，即因为a指向的数据是int，int的宽度是4个字节
- 修改1、如果将int改成char，结果是多少呢？
- 因为a指向的数据是
char，char的宽度是1个字节
void func(){ char *a; a = (char *)100; a++; printf("%d", a); } <!--打印结果--> 101
- 修改2：如果int改成int呢，结果是多少？*
- 因为a指向的数据是
int*，是一个指针，指针的宽度是8个字节
void func(){ int **a; a = (int **)100; a++;//指针的自增自减和执行的数据类型宽度有关 printf("%d", a); } <!--打印结果--> 108
- 修改3：如果将 a++ 改成 a = a + 1 呢？
自增自减和编译器有关！- 注：这里的+1，加的是一个步长，而a的步长是（int*）即8个字节
void func(){ int **a; a = (int **)100; // a++;//指针的自增自减和执行的数据类型宽度有关 a = a + 1; printf("%d", a); } <!--打印结果--> 108
指针和指针求差值
有以下代码，两个指针相减的结果是多少？
void func(){ int *a; a = (int *)100; int *b; b = (int *)200; int x = a - b; printf("%d", x); } <!--打印结果--> -25
- 因为 （100-200）/int的宽度 = -100/4 = -25
- 注：
指针的运算单位是执行的数据类型的宽度 - 问题：指针是否可以 if-else 比大小?
- 可以的，我们知道类型是可以相互转换的，但是结构体和基本类型是不能相互转换的
- 任何类型都可以使用
&（取地址符号）取值
void func(){ int *a; a = (int *)100; int *b; b = (int *)200; if (a > b) { printf("a > b"); }else{ printf("a <= b"); } } <!--打印结果--> a <= b
指针的反汇编
定义一个指针，并赋值，查看其汇编代码
void func(){ int *a; int b = 10; a = &b; }
以下是代码运行的汇编以及分析
指针数组
问题1：通过下面这种方式能否将数组中的数组正确取出？
void func(){ int arr[5] = {1, 2, 3, 4, 5}; for (int i = 0; i < 5 ; i++) { // printf("%d", arr[i]); printf("%d",*(arr + i));//这里使用arr++不可以，因为编译器不允许 } }
运行发现是可以的，所以有以下对等关系：
- 对等关系：
int *a == arr[0] == arr
问题2：如果将arr赋值给指针a，for循环中 a++是否可以？
void func(){ int arr[5] = {1, 2, 3, 4, 5}; int *a = arr; for (int i = 0; i < 5 ; i++) { // printf("%d", arr[i]); printf("%d",*(a++)); } }
运行发现也是可以的
指针的基本用法
- 定义一个指针，并从指针中取值
void func(){ char *p1; char c = *p1;//取p1的值 }
运行发现，崩溃报错：原因是以0作为地址取值，以下是对应的汇编分析
指针的基本用法-01
*如果修改成 (p1+0) 的形式呢？
void func(){ char *p1; char c = *p1;//取p1的值 char d = *(p1+0); }
查看汇编代码：
p1指针指向sp+0x8栈区域里的值，相当于p1 -> （X8)0x0c相当于取X8的值，即[X8]d同样的是取X8的值，即[X8]
如果改成 (p1+1) 的形式呢？
void func(){ char *p1; char c = *p1;//取p1的值 char d = *(p1+1); }
查看汇编：
p1指针指向sp+0x8栈区域里的值，相当于p1 -> （X8)0x0c相当于取X8的值，即[X8]d同样的是取X8的值，即[X8+0x1]
如果将 char类型 改成 int类型 呢？
void func(){ int *p1; int c = *p1;//取p1的值 int d = *(p1+1); }
以下是func函数的汇编，此时d是取[x8+0x4]地址的值，因为int是4个字节，0x4就是int类型的步长
如果将 int 类型改成 int 类型呢？*
void func(){ int **p1; int *c = *p1;//取p1的值 int *d = *(p1+1); }
- 查看汇编，此时
d是取[x8+0x8]地址的值，因为int*是一个指针，占8个字节，0x8就是int*类型的步长
- int** 需要拉伸多少个字节？
实际需要3x8=24字节，由于是汇编是16字节对齐，所以需要sub减0x20 - 此时多增加一个
int* p2，栈空间拉伸多少字节？
发现仍然是0x20
再多增加一个char c1呢？
此时超过了32，所以需要再多拉伸16字节
多级指针
1、二级指针
有以下代码
void func(){ int **p1; int c = **p1; }
运行崩溃，查看其汇编
x8取的是*p1（即一级指针的地址）的值w9取的是**p1（即二级指针的地址） 的值
2、多级指针加法运算
void func(){ char **p1; // char c = p1+2; //此时的+2是 +0x10（执行数据类型是char*） char c = *(*(p1 + 2) + 2);//最外层的+2，是加0x2（执行数据类型是char） }
- 此时c中的
+2是+0x10（执行数据类型是char*） - 此时d中
最外层的+2，是加0x2（执行数据类型是char）
如果是下面这种形式呢？
void func(){ char **p1; // char c = p1+2; //此时的+2是 +0x10（执行数据类型是char*） // char c = *(*(p1 + 2) + 2);//最外层的+2，是加0x2（执行数据类型是char） char c2 = p1[1][2]; //与上面等价 }
p1[1]此时的1表示0x8（类型是char*）p1[1][2]此时的2表示0x2（类型是char）
- 从汇编结果来看
p1[1][2]与*(*(p1 + 2) + 2)是等价的
总结
- 编译器优化：
- 1、设置：
BuildSetting->Optimization Level - 2、优化原则：对结果没有任何影响的代码会被编译器优化
- 3、编译器优化，本质是LLVM的优化过程，实际上优化的是汇编代码（可以理解为
汇编指令会减少）
- 指针：
- 1、指针的
自增自减和指向的数据类型宽度有关，是按照指向的数据类型来运算的（即指针的宽度 - 步长） - 2、指针的
运算单位是指向的数据类型的宽度 - 3、指针可以通过
if-else比大小，因为类型是可以相互转换的
