一、框架
1、Mac系统及常用工具、进制;C数据类型、常量变量、运算符、表达式、格式化输入输出
2、关系运算符、逻辑运算符、if、条件运算符、switch..case..
3、while循环、do..while循环、for循环
4、一维数组、数组排序、字符数组
5、二维数组、字符串数组、多维数组
6、函数分类、函数声明和定义、函数调用,形参实参、函数嵌套调用
7、结构体、结构体数组
8、指针
9、高级指针
10、程序存储区划分、动态申请内存、内存操作函数
11、函数指针、回调函数、动态调用
二、知识总结
一、基础：
1、进制、位权、1字节等于8位（位是计算机的最小储存单位，字节是计算机最小存储单元）、十进制转换其他进制：连除倒取余，其他进制转换十进制：按权求和
2、单行注释：// 多行注释： /*/ （内容写在量型号之间）
3、数据类型：整形类型、浮点类型、字符类型。
整型类型：长整形（long 4/8）、整形（int 4）、短整型（short 2)
浮点类型：单精度（float 4）、双精度（double 8）
字符类型：字符类型（char 1）
4、常量：程序运行期间不能被改变的量。
常量 类型：整型常量、浮点型常量、字符型常量
变量：实际上是储存区域，也可以做表达式，是程序运 行期间可以被改变的量。
变量定义：由类型符号、变量名、初始值三部分组成（如： int a = 5;）
变量命名规则：由数字、字母、下划线组成的，但不能 以数字开头，不能与关键字重复，不能重复使用变量名（同一作用域），见名知意。
5、赋值运算符：= 把右边的值赋给左边 优先级别最低
算数运算符：+， -， ， / 整型两边相除取整，除数不能为0，% 两边均为正数 ，++ 自增运算符、- - 自减运算符：（它俩在前，先执行，它俩在后，后执行。
6、复合运算符：+= （a += b; 相当于a = a + b）; -=; *=; /=; %=;(语法含义同上)
7、表达式：由常量、变量与运算符组合而成（注：表达式会有返回值）
8、输出函数：printf()； 输入函数 scanf()（注：以回车确定输入结束，只有大回车键才会结束；不要再格式串后面加’n’字符，否则会抵消人工输入的回车）。
转化符：%c->char; %d->int; %sd->short; %ld->long;%f->float、double。
9、转换格式控制：最少占4位：
printf(“%04d”,12); //不足补0
printf(“%4.2f”,1.2345); //保留小数点后两位
printf(“%-4d”,12); //左对齐
n回车符； 印 %%打印%；
二、运算符
1、BOOL类型：只有YES（1）和NO（0）两个值；
bool类型：由ture（非0数字）和flase（0）两种值；
BOOL和bool区别：1）、在C中只有小布尔没有大布尔； 2）、在C和OC中小布尔中非零为真，零为假；3）、在OC中大布尔中1为真，0为假，其它数字原样输出，不做判断条件
2、关系运算符：用于比较运算，结果值有真假两种，结果值由BOOL类型储存
> = <= == ！=
3、逻辑运算符：由逻辑运算符组成，结果也是非真即假
&&（逻辑与）：一假即假（有一边为假则结果为假）
||（逻辑或） ：一真即真（有一边为真则结果为真）
！（逻辑非） ：对表达式结果取反
4、条件运算符：条件表达式？表达式1：表达式2
如果条件为真，则执行表达式1。 如果条件为假，则执行表达式2。
5、枚举类型：属于构造类型，是一组由符号的整型常量，一一罗列所有状态，罗列所有结果。 enum枚举名{枚举值表}
目的和作用：提高程序可读性；将人能看懂的标示符与计算机能识别的数字建立对应关系
三、程序的三种结构：
1、顺序结构：按照语句顺序执行
2、分支结构：判断条件在两个语句序列中选择，一旦进行判断必须选择其中一个。
if语句：形式一：if (条件表达式) {语句；}
形式二：if (条件表达式) {语句1；} else{语句2；}
形式三：if (条件表达式1) {语句1；} else if条件表达式2）{语句2；} else{语句3；}
switch语句：多分支语句，通过判断整形表达式的值，来判断执行那个语句。常与case配合使用。
break：跳出本层循环，如果外层还有循环的话，则执行外层循环，如果外层没有循环，则执行循环后面的代码。（常与if、switch连用）
continue：跳出本次循环，跳出本次循环，遇到continue后，不管continue后面有无代码，均不执行，提前结束当前循环，开启下一次循环。(常与if连用)
arc4random()：返回随机数的函数。 如果要一个随机数在【a, b】范围内的整数。公式为：arc4random() % (b - a +1) + a;
3、循环语句：在满足一个条件的情况下反复执行一个语 句序列。
while语句：while(条件表达式){语句；}条件表达式为真执行循环体，一旦为假立即停止执行。
do…while…语句：do{语句；} while （条件表达式),先执行循环体，再判断循环条件直到不满足，才结束循环。
for语句：for(循环变量初始化；循环条件；循环增量){语句；}循环条件为真才执行循环体。
四、一维数组
一维数组：属于构造结构，是由相同类型的成员组成的一组数据。
数组名：存储不同数据类型的数组有各种对应的名称（名称可以随意起），但 要见名知意。
元素：数组由多个成员组合而成，每个成员被称为“数组的元素”
1、定义一个数组
int array[3] = {1, 2, 3};
int：声明数组类型 array：数组名 [5]：数组长度（注：定义数组时，可以省略元素个数，因为编译器会自动推断出元素个数，但是“[]”坚决不能省略。） { } ：给数组赋值，元素之间用逗号分隔开（注：1）定义数组时，可以不给每一个元素赋值，没有赋值的元素系统会默认为0。2）定义数组时，给定了数组长度，首元素为0，其他元素不赋值，则默认为0，这样五个元素均为0。3）大括号中最好赋上初始值，因为没有赋值是系统会根据Xcode编译环境来赋值，有时可能有，有时可能无，这样就会出现定义不明，所以建议赋上值。）
2、数组的内存占用
1）使用sizeof()函数求数组占字节数
printf("array[3]数组所占字节数%ld", sizeof(array));
结果：12 因为每个int类型占4个字节，有3个元素，所以共12个字节 。
2）利用sizeof()函数求数组元素个数
先求出数组所占字节数，再求出其中某个元素所占字节数，再相除就得出数组元素个数。
int array[5] = {4， 6， 7， 2， 8};
int a = (sizeof(array) / sizeof(array[1]));
printf("a = %dn", a); 结果为：a = 5
3、数组元素的访问方式：数组名+下标
1）int array[6] = {12, 21, 32, 23, 25};
访问array中的32这个元素： 数组名：array，下标:从零开始计数，32在第3个位置上，所以32的下标是2。
int temp = array[2];
printf("temp = %d, array[2] = %dn", temp, array[2]); 结果：32，32
（注：可以直接访问，打印出来，也可以把值赋给另一个相同类型的变量再打印出来）
2）数组下标越界：数组下标超过了数组长度，访问了不属于数组的内存空间。在C中是没有“数组下标越界保护”机制，所以在写代码时，要避免下标越界。
3）修改数组元素
3.1)修改array中的第二个元素为62
int array[6] = {12, 21, 32, 23, 25};
array[1] = 62;
printf("array[1] = %dn", array[1]); 结果：array[1] = 62
3.2) 定义一个新的数组，array1,将array的元素，原样赋给arrary1.
int array[5] = {12, 21, 32, 23};
int array1[5] = {0};
for (int i = 0; i < 5; i++) {
array1[i] = array[i]; // 数组的下标可以是常量，也可以是变量
printf("array1[%d] = %dn", i, array1[i]); // 数组的输出需要for循环进行遍历
}
// array1 = array; 数组中不能整体访问数组元素，也不能整体赋值，而要逐一的遍历数组元素，进行访问、赋值、输出。
// 定义一个具有20个元素的数组，每个元素的取值范围是【30，70】，求数组元素的和
// 1.定义一个整型数组长度为20
int array[20] = {0};
//2.开启一个for循环，使用循环给数组元素赋值
for (int i = 0; i < 20; i++) {
//2.1 生成【30，70】之间的数
int temp = arc4random() % (70 - 30 + 1) + 30;
//2.2 将生成的随机数赋值给对应的元素
array[i] = temp;
printf("array[%d] = %d\n", i, array[i]);
}
//3.求数组元素的和
//3.1定义一个保存和的变量
int sum = 0;
//3.2 使用for循环遍历数组元素，同时将元素累加起来
for (int i = 0; i < 20; i++) {
// 3.2.1 获取当前数组元素并将获取到的元素加起来
sum = sum + array[i];
}
printf("元素总和为%d\n", sum);
// 定义三个数组，将随机产生的数放入其中两个数组中，将这两个数组的值加起来放入第三个数组中
// 1、 定义三个数组，并初始化。
int array1[10] = {0};
int array2[10] = {0};
int array3[10] = {0};
// 2、 使用一个for循环，给第一个数组和第二个数组赋值，将两个数组个元素加起来，交给第三个元素。
for (int i = 0; i < 10; i++) {
// 2.1、 分别把生成的随机数赋给两个数组
array1[i] = arc4random() % (40 - 20 + 1) + 20;
array2[i] = arc4random() % (40 - 20 + 1) + 20;
// 2.2、两数组进行相加
array3[i] = array1[i] + array2[i];
// 3、 打印验证结果是否正确
printf("array1[%d] = %d, array2[%d] = %d, array3[%d] = %d\n", i, array1[i], i,array2[i], i,array3[i]);
}
4、冒泡排序
int array[5] = {12, 45, 23, 42, 56};
//趟数 = 元素个数 - 1；每趟比较的次数 = 元素个数 - 当前的趟数
//两层for循环，外层丛植比较趟数、内层控制比较次数
//趟数
for (int j = 0; j < 5 - 1; j++) {
//次数
for (int k = 0; karray[k + 1]){//因为每趟比较都要从下标为0开始，j在每次从外层循环进入内层时，都要被初始化为0。因为每次比较，下标都要加一，j在每次内层循环时，也会加一，所以，在这里是用j做下标是没有问题的。
//满足交换条件，开始交换位置。
//1.定义一个临时变量
int temp = array[k];6
array[k] = array[k + 1];
array[k + 1] = temp;
}
}
}
for (int i = 0; i < 5; i++) {
printf("%d ", array[i]);
}
5、字符数组
字符数组：保存字符的数组就是字符数组。有’0’结束标识的字符数组也称为字符串。
定义一个字符数组：声明类型、数组名、数组长度、赋初值
char char_Array[5] = {'h', 'e', 'l', 'l', ‘o’};
//每个字符占一个字节，数组长度是5，所以数组占5*1个字节的内存。
char char_Array[5] = {'h', 'e', 'l', 'l', 'o', '0'};和char char_Array[5] =“hello”;
是同一个意思都便是定义字符串hello。
字符串和字符数组的区别：
如果字符数组最后一个字符末尾没有‘0’，则是一个字符数组
如果字符数组最后一个字符末尾有‘0’，则是这个字符数组就是字符串。
字符串操作函数
strlen()：返回字符串的有效字符个数
strcpy():字符串拷贝函数:把第二个参数的值拷贝给第一个参数
strcat() 字符串拼接:把第二个参数的值，拼接到第一个参数的后面
strcmp() 字符串比较:第一个参数大于第二个参数返回一个正整数，第一个参数小于第二个参数，返回一个负整数，两个参数相等，返回零。
五、函数
1、函数：完成某一功能的代码段。
函数名：给这段代码取一个名字，以后就可以通过这个名字来代替这段代码，遵守变量名的命名法则。
函数参数： 有的函数在完成某一任务时需要的材料，我们把在完成任务所需的材料叫函数的参数。 在被调函数中，参数叫“形参”，在主调函数中，参数叫“实参”。
函数参数传递：将实参的值拷贝一份到形参变量的空间中，在被调用函数中操作的参数是新开辟的内存的数值，和实参没有关系。
参数列表：如果没有参数，可以用void修饰，也可以什么都不写，但是小括号不能省略。
函数的返回值：有的函数在完成任务之后，需要把任务结果返回给主调函数，就可以通过return语句来将值返回。注意：return只能返回一个值，同时不能返回数组。
return：return标志着函数的结束，如果return后边有数值，则将这个数值交给主调函数。当return只负责结束函数执行时，可以省略return。return后⾯的语句不再执行。
函数定义：一般定义在main函数前，函数会遭遇嵌套定义。
返回值类型 函数名 （参数列表） {函数实现……return 返回值；}
函数的调用:必须要先定义出来这个函数，定义之后才能调用
函数调用方式：函数名+参数列表
函数类型：无返无参，无返有参，有返无参，有返有参
返回值类型：如果无返回值，必须要使用void修饰符
2、.h和.m文件
1）如果使用多个文件来管理定义函数时，函数的声明要放在.h文件中，函数定义在.m文件中。
2）由于函数的声明和定义在其他文件中，所以想使用该函数，必须先引入声明部分，也就是.h文件
import"文件名.h" 把这个放在 主函数和系统头文件之间
3） 如果函数定义在主调函数（main）函数之前，函数的声明可以省略，因为在编译时，编译到主调函数时，已经知道该函数被调函数的意义，所以不会出现异常。如果函数定义在主调函数（main）函数之后，务必要在main函数之前对函数进行声明。
4）声明的意义在于：告诉系统，后面将会出现一个该类型的函数。一个完整的自定义函数，应该包括：函数声明、函数定义、函数调用，共三部分。
5）函数声明的方法:将函数的“返回值类型+函数名+形参列表+；”写在导入头文件语句下面，就是一个函数声明。
3、函数的嵌套调用
1）函数可以嵌套调用：在一个函数中，调用另一个函数完成某项功能，这就是函数的嵌套调用。函数可以嵌套调用，但是函数不可以嵌套定义。
2）函数不可以嵌套定义：在定义一个函数时，又定义另一个函数，就叫函数的嵌套定义，这种行为是不允许的。
4、函数的递归调用
函数递归时一定要有出口，否则会造成程序递归环路（死递归），那么程序一定会崩溃。递归调用：自己调用自己完成某项功能。
5、变量的作用域
// 局部变量：只在当前作用域中起效
// 全局变量：不属于任何一个作用域的变量就是全局变量，全局变量可以在当前文件中任何一个地方被访问到（从创建的位置开始，一直到文件结束）
// 如何确定作用域？使用{}来确定作用域，一对大括号，就确定了一个作用域。
六、结构体
1、什么是结构体？
1、)结构体是一种构造类型，由其他基本数据类型组合而成一种新类型。与数组的区别是：构成结构体的基本数据类型可以不相同，数组必须是相同类型的数据构成。
2、)结构体必须先声明，声明结构体由哪些数据类型构成的，相当于基本数据类型的“int/char/double”之类的类型说明。
3、)声明完成后，就在文件中创造出了这种新的类型，就可以使用这种新的类型定义变量来保存数据了。
2、结构体类型的声明
struct+结构体名+{成员标量}+； 结构体声明在.h文件或主函数与系统头文件之间。
eg:struct student {
char name[20];
int age;
char gender;
};
3、结构体定义
1）struct关键字+结构体名，共同组成了变量的类型修饰符。
struct+结构体名+结构体变量名 = {值1，值2}；
eg:struct student stu1 = {"zhangSan", 23, 'm'};
2）结构体成员变量的访问
方式：使用结构体变量名+“.”+”成员变量”的方式访问
eg:访问姓名：stu1.name 访问年龄：stu1.age 访问性别：stu1.gender
3)结构体成员变量的修改
先访问到对应的成员变量，然后再修改值
修改成员年龄：stu1.age = 22;
修改成员性别：stu1.gender = ‘f’;（输出打印时用%c）
修改成员姓名：stu1.name = "shuKui"; (这是错误的形式)
因为字符串在C中使用时，字符数组类型保存的数组不能整体赋值，所以使用普通的修改成员变量方法在这里无效，需要使用字符串拷贝函数，达到修改的目的。
strcpy(stu1.name, “shuKui"); （使用strcpy()函数进行字符串的复制替换）
4、结构体数组
保存结构体变量的数组，就是结构体数组。结构体数组和基本数据类型的数组一样，只能保存相同的数据元素（结构体变量类型必须相同）
1）声明一个father类型的结构体数组
typedef struct father {
char name[20];
int age;
}father;
2）定义一个father类型的结构体数组
father father[4] = {
{"zhangsan", 12},
{"laowang", 55},
{"xiaotian", 66},
{"xiaoyan", 22}
};
3)访问成员变量的方式：数组变量名 + 下标 + ‘.’ + 成员变量名
访问姓名：father[0].name
访问年龄：father[2].age
七、指针
1、指针：指针就是内存单元编号的另一种称呼。每个内存单元都有一个编号，这个编号就是内存单元的地址，也被称作指针。
指针变量：用来保存“内存单元”地址的变量，就是指针变量。
2、定义一个指针变量
1）int p = NULL; int a = 12;
// int : 类型声明符，表示变量p是一个整型指针变量。
// int:告诉系统取值时，应该从当前位置取多少字节数据。int表示连续取4个字节。它与指针变量所占字节无关，指针变量所占字节数只与操作系统有关，64位环境下占8字节，32位环境下占4字节。
// 不能使用指针计算数组元素的个数，因为指针所占的内存的字节数至于操作系统的位数有关
// p：变量名，一般我们将指针类型的变量取名叫p。
// NULL:C语言中，使用NULL代替“空”的意思，将NULL赋给指针，则指针此时保存的是内存起始地址，指针指向内存的起始位置。
printf("%pn", p); // 打印结果0x0，表示内存的起始位置。
// 使用%p作为占位符，来打印指针变量所保存的地址。
2） &：取地址符号，将后边变量的地址取出来，交给指针保存。
将整型变量a的地址，交给整型指针变量p保存。
p = &a; printf("%pn", p);
3）：取值运算符，将指针所指的内存地址中保存的数据取出来。
注意：在不同的位置的含义不同，出现在指针定义的位置，表示证明后边的变量名是一个指针。如果前边没有类型修饰符，则表示指针所指向的地址的数值。
int b = p; printf("%dn", b);
4)用指针修改变量 a 的值
*p = 23; printf("%dn", a);
5）指针重指向：就是指针把它里面保存的地址进行个更换。
p = &c; 指针发生了重指向，有原来的指向a改变为指向b。
3、指针的算术运算
p++; // 指针变量进行加法操作，指针所保存的地址将会加若干个单位的字节，每个单位占用的字节数取决于指针的类型。指针从低地址向高地址移动。
p- -; // 指针变量进行减法操作，指针所保存的地址将会减若干个单位的字节，每个单位占用的字节数取决于指针的类型。指针从高地址向低地址移动。
// 普通的加减运算：如果没有小括号干预优先级，则先取值，再将值进行加减操作
// 自增、自减运算：先处理自增、增减，处理完成后，再进行取值操作。
4、指针与数组
1）数组名就是数组的首元素地址,我们可以定义一个指针变量,来存储数组的首地址,这样指针变量指向的就是这个数组。
// 定义一个指针，将指针指向数组array的首地址
int p = array; // 数组名本身就是地址，所以不需要取地址符&
// 访问数组元素：数组名+下标针+下标
printf("array[1] = %dn", array[1]);
printf("p[1] = %dn", p[1]);
// 打印指针指向的地址和数组首元素的地址以及数组名指向的地址
printf("%pn", p);
printf("%pn", &array[0]);
printf("%pn", array);
2）数组名和指针的区别:
2.1）指针指向数组的首地址后，可以向数组名一样访问数组元素（数组名/指针）；
2.2） 指针变量的地址可以被修改，但是数组名是一个常量，它所保存的地址不能被修改（数组名不能重指向，但是指针可以重指向）
3）// 使用指针的方式来访问数组元素
int temp = p; int temp1 = (p + 1); int temp2 = (array + 1);
// 此时指针P的指向并没有发生改变，而是产生了一个"新指针（p + 1）"指向了第二个元素。
// 通过修改指针P的指向，来访问数组元素；
int temp3 = (++p); printf("temp3 = %dn", temp3);
int temp4 = (++array); // 因为数组名是常量，所以不能通过修改数组名的地址修改数组元素。（这种表示是错误的）
5、使用指针遍历数组
int array[5] = {23, 12, 34, 23, 45};
int *p = array;
6、指针与字符串
1）// 定义一个字符数组用来保存字符串"hello"
char string[] = “hello"; // hello 是存储在常量区的，string将hello拷贝一份放到栈区进行使用。
// 定义一个char类型指针指向string
char *p = string; //这种情况是指针指向有string开辟的栈区的hello的首地址
// 使用指针下标为0的元素改为’a’
p = ‘a’;
// 使用指针操作字符串：输出字符串，使用%s做占位符，参数用指针名，或数组名均可。
printf("%sn", p);
// 使用指针便利字符串
for (int i = 0; i < strlen(string); i++) {
printf("%cn", (p+i));
}
2）// 指针p此时指向常量区，所以不能修改常量字符串的值。常量字符串，只能访问不能修改。
// char p1 = “hfjhsdjfh"; // 这种情况是指针指向常量区
// printf("%sn", p1);
// 总结：指针指向栈区的字符串，可以访问进行修改，但是当指针指向常量区时，只能访问不能修改。
7、指针数组
1）char str[3] = {"ios", "ipad", “imac”};这是指针数组
// str[0],相等于第一个指针，指向ios首地址。
// str[1]，相当于第二个字符指针，指向常量区的ipad字符串的首地址。
// str[2]，相当于第三个字符指针，指向常量区的imac字符串的首地址。
char srt3 = {"ios", "ipad", “imac"};这是二位数组（两个表达意思一致）
// char 类型的数组里存的并不是三个字符串，而是三个字符串的首地址。如果用数组存储三个字符串，需要使用二维数组。
// 指针数组中保存的元素都是指针。
// str本质是一位数组，str数组中存储的时char类型的指针。
2）访问
printf("%sn", str[1]); // 这就访问了str[3]中的第二个元素（字符串）
3）修改：修改指针数组的元素。在这里，就是修改指向。
str1[2] = "Happy Birthday";
printf("%sn", str1[2]);
4）使用指针打印：1、字符串的地址2、一个完整的字符串3、字符串中，下标为3的字符
// char p2 = "i love";
// printf("%pn", p2);
// printf("%sn", p2);
// printf("%cn", (p2+3));
// 打印ipad中的第二个字符。
char str2[3] = {"ios", "ipad", “imac"}; printf("%cn", (str2[1]+1));
8、指针作为函数的参数
// 对两个整型数值进行交换
// 1、函数exchangeNum定义
void exchangeNum(inta, intb){ 传入的参数必须是指针（地址），这里坚决不能传入数组名，虽然数组名是地址，但是数组是常量怒能被改变所以不能传。（用指针传参本质是把要交换的变量的地址传过去）
int temp = *a;
a =b;
*b = temp;
}
int main(int argc, const char * argv[]) {
int x = 23, y = 88;
int *p1 = &x;
int *p2= &y;
// 调用exchangeNum函数
exchangeNum(p1, p2);
printf("x= %d, y = %dn", x, y);
return 0;
}
9、结构体指针
指向结构体变量的指针就是结构体指针。结构体指针的类型必须和结构体变量的类型一致。
// 声明一个Student类型的结构体变量
typedef struct student {
char name[20];
int age;
float score;
char gender;
}Stu;
// 定义一个Student类型的结构体变量，并赋值
Stu stu1 = {"xiaoZeMaLiYa", 22, 98.15, ‘f'};
// 使用结构体变量名+.+成员变量名的方式访问
printf("%sn", stu1.name);
printf("%cn", stu1.gender);
// 定义一个指针，来指向这个结构体变量
Stu *p = &stu1; // 结构体变量名只是一个名称所以需要取地址符
// 使用指针访问结构体变量的成员变量
// 方法一：先取出结构体变量的值，再通过“.”找到它的成员变量
printf("%sn", (p).name); // 由于.运算的优先级高于，所以需要用小括号干预他们的运算顺序。
printf("%dn", (*p).age);
// 方法二：使用指针名+ -> 访问结构体的成员变量。
printf ("%sn", p->name);
printf("%dn", p->age);
// 访问name成员变量的首个字符及第六个字符
printf("%cn", *(p->name));
printf("%cn", *(p->name+5));
10、指针与结构体
结构体数组的数组名就是一个结构体指针，只不过数组名是一个常量，不能修改数组名保存的地址。
typedef struct teacher{
int num;
char name[20];
char gender;
float score;
}Teacher;
Teacher *stuu = student;
// 使用数组名+下标的方式，访问第一个元素的name成员变量
printf ("%sn", student[0].name);
// 使用指针取值的方式来访问第二个元素的num成员变量（不常用）
printf("%dn", (*(stuu+1)).num);
// 使用指针和 -> 的方式访问第三和元素的gender成员变量
printf("%cn", (stuu+3)->gender);
八、宏
1、普通宏
define kMac 33 // 宏定义：在程序，只要遇到kMac,在编译之前会自动替换为后面的数。 宏不是变量
命名规则： 纯大写或 k + 驼峰法
2、带参宏
define SUM(A,B) ((A) * (B)) // 带参宏只是将参数原样替换所以一般情况下，要在表示参数的字符上，添加小括号，防止出现运算符优先级别的问题。
// 带参宏和函数区别： 带参宏会增加预编译的时间，但是不会加大CPU的运算速度；函数虽然在预编译阶段非常快但是占用的CPU内存会加大，增大硬件损耗。
3、条件编译指令
作用：按条件不同，编译不同的代码
1）第一种形式:如果宏定义了标示符，则编译第一段代码，否则编译第二段代码
ifdef 标识符
代码段1
else
代码段2
endif
2）第二种形式:如果没有定义表示符，则编译代码段1，否则编译代码段2
ifndef 标识符
代码段1
else
代码段2
endif
3）第三种形式：如果 常量表达式结果非0 编译器编译代码1，否则编译代码段2
if 常量表达式
代码段1
else
代码段2
endif
