零：声明、定义、初始化
声明：extern 可以置于变量或者函数前面，提示编译器遇到这个变量或者函数的时候，在其他/当前模块里寻找。 extern int a; // b.c 有个全局变量a，那么可以在a.c里声明这个a，然后拿过来用，但是并不代表我重新定义了一个a extern int function(int a, double b, char c); // 注意：函数在进行声明的时候，extern 是默认可以省略的。
定义：没有加上 extern 就是定义了。定义后的变量是有存储空间的，可以获取到这个变量的地址，但是不一定有值。 int a; int arr[10];
初始化：定义变量的同时进行赋值操作。 int a = 10; int arr[10] = { 0 };
数据类型： 在C语言里的数据类型分为四大种： 1. 基本类型 Linux 64 Windows 64 Linux 32 Windows 32 字符： char 1 1 1 1
整型： short 2 2 2 2 int 4 4 4 4 long 8 4 4 4 long long 8 8 8 8 size_t 8 8 4 4
浮点型: float 4 4 4 4 （实型） double 8 8 8 8
2. 构造类型 数组：存储了n个相同基本类型的数据，举例：sizeof(int) * n 个字节大小 char str1[5] = "haha"; // 只要用" "括起来的就是字符串，只要是字符串最后一位就是'\0' char str2[5] = {'h', 'a', 'h', 'a', 'h'}; str1[2] = 'm'; printf("%s\n", str1);
int iarr[5] = {1, 2, 3, 4, 5}; float farr[5] = {1.1, 2.2, 3.14, 4.15, 5.001};
结构体：存储了n个可以不相同基本类型的数据 struct 联合体/共同体： 存储n个可以不相同基本类型的数据，但是这种类型里的所有数据共享同一块内存空间，内存大小是最大的那个数据类型大小 union 枚举：存储了n个相同基本类型的数据，但是使用的时候只能取其中一个值，内存大小是 sizeof(int); enum
3. 指针类型 32位占4个字节，64位占8个字节 int *p; // 指针类型变量p就是用来存储地址的，定义指针时候的数据类型，代表这个指针指向的内存空间里存储的值的类型 int a = 10; p = &a; *p = 20; printf("%d\n", a);
char *str = "haha"; // char *str 和 char str[5] 都是存储字符串，但是str是一个指针，str是一个数组名 printf("%s\n", str); // char str[5] 存储的"haha"是在栈区, char *str 指向的 "haha" 是在常量区，str存储的是这个字符串在常量区的首地址。
4. 空类型 void 变量 ：意思是空类型变量，不接受任何数据 void 函数 ：意思是没有返回值 void 指针 ：意思是可以接收任何其他类型的指针
一、 字符串函数 <string.h> 1 strlen(char *str); 这个函数返回值是一个字符串的有效长度(除去'\0'), 有别于 sizeof() 运算符;
2 strnlen(char *str, int maxlen); 这个函数是返回 maxlen 长度以内、不含'\0'的字符串的长度。
3 strcat(char *str1, char *str2); 将参数str2 追加到 str1的后面（覆盖str1后面的'\0'）
4 strncat(char *str1, char *str2, int maxlen); 将参数str2 追加到 str1的后面，但是只追加str2的前maxlen个字节长度的字符串。
5 strcmp(char *str1, char *str2); 按字符依次比较两个字符串，直到遇到不同的字符为止： 如果str1大于str2，返回正数（Windows下是返回1，Linux下是返回两个不同字符串的ascii码差值） 如果str1小于str2，返回负数（Windows下是返回-1，Linux下是返回两个不同字符串的ascii码差值） 如果两个字符串相等，返回 0
举例： str1 = "abcde"; str2 = "c"; strcmp(str1, str2); 返回值是（Windows下是返回-1，Linux下是返回两个不同字符串的ascii码差值： -2）
6 strncmp(char *str1, char *str2, int maxlen); 和 strcmp()函数返回值相同，但是只比较前 maxlen 个字符;
7 strcpy(char *str1, char *str2); 将参数 str2 的字符串拷贝到参数 str1 里面。（拷贝的字符包括'\0'）
8 strncpy(char *str1, char *str2, int maxlen); 将参数 str2 的前 maxlen 个字符拷贝到 str1 里。
9 strchr(char *str, char ch); //原来是 int ch，但是函数在调用的时候，会转换成char ch 在str中查找指定字符ch，如果找到的话返回ch在str中的位置，如果没找到，返回 NULL // (void*) 0
10 strstr(char *str1, char *str2); 在str1中查找指定字符串str2，如果找到的话返回str2在str1中的位置，如果没找到，返回 NULL
11 strtok(char *str, char delim); 分解字符串 str 为一组字符串子串，用delim做为字符串的分隔符。 strtok()函数每次分隔会把分隔符的位置置为 '\0', 同时会破坏原先字符串的完整性; 调用函数前的字符串和调用函数后的字符，已经不一样了。所以我们在做字符串分隔的时候，更推荐使用 sscanf();
12 sscanf(char *str, char *format, argument...); scanf()函数是从键盘上读取用户输入，然后把值写到变量里; sscanf()函数是从str里读取数据，按照format格式，将数据写入到变量里。 返回值是成功写入的数据数量;
int a, b, c; char s1[10] = { 0 }; char s2[10] = { 0 }; char s3[10] = { 0 }; sscanf("2016 - 05 - 31", "%d - %d - %d", &a, &b, &c); // 按照 %d - %d - %d 的格式分隔，把2016、05、31 这三个整数写入到a、b、c里 sscanf("2016 - 05 - 31", "%s - %s - %s", s1, s2, s3); // 按照 %s - %s - %s 的格式分隔，把2016、05、31 这三个字符串写入到s1、s2、s3里
13 sprintf(char *str, char *format, argument...); printf()函数是把格式化后的结果输出到屏幕上; sprintf()函数是把格式化后的结果写入到字符串str里; 返回值是 str被写入的字节数，不包括'\0';
char i[10] = "I"; char you[10] = "You"; char str[100] = { 0 };
sprintf(str, "%s love %s", i, you); // 输出字符串"I love You"到字符串 str 里 sprintf(str, ".3f", 0.1234567); // 输出字符串 " 0.123" 到字符串 str 里（原先的内容会被清空) 14 字符串转换函数 <stdlib.h> atoi(); 把一个 char 类型的数组转换成一个 int. itoa()把一个 int 类型的数字转换成char类型的字符串(只能在Visual C++ 编译器下使用); // Linux是没有的 atoll(); 把一个 char 类型的数组转换成一个 long long.
atof(); 把一个 char 类型的数组转换成一个 float.
举例： char str[10] = "....."; //int float long long int / float / long long n = atoi(str) / atof(str) / atoll(str); printf("%d / %lf / %ld\n", n);
二、函数参数的进栈顺序和运算顺序（引伸出各个平台编译器的不同）
1. 大端对齐和小端对齐： unsigned int num = 0x12345678;
大端对齐：数值的高位字节存储在内存的低位地址上，数值的低位字节存储在内存的高位地址上。
地址： 0xff1100 0xff1101 0xff1102 0xff1103
数值： 0x12 0x34 0x56 0x78
小端对齐：数字的高位字节存储在内存的高位地址上，数值的低位字节存储在内存的低位地址上。
地址： 0xff1100 0xff1101 0xff1102 0xff1103
数值： 0x78 0x56 0x34 0x12
大端：IBM、SUN的服务器CPU都是大端对齐，最早的苹果电脑PowerPC也是大端。 小端：x86\AMD64（美国）架构CPU（复杂指令集）都是小端对齐，ARM（英国）架构CPU（精简指令集）都是小端对齐。 x86 intel AMD64 AMD
2. 函数的进栈顺序
#include <stdio.h> void func(int a, int b, int c) // 三个形参（本质是局部变量），接收实参的值 { printf("a = %d : %p", a, &a); printf("b = %d : %p", b, &b); printf("c = %d : %p", c, &c); }
int main(void) { func(100, 200, 300); // 三个实参 return 0; }
// Ubuntu GCC 下编译结果 a = 100 : 0xbf8decb0 +4 b = 200 : 0xbf8decb4 +4 c = 300 : 0xbf8decb8
// Windows Visual C++ 下编译结果 a = 100 : 0x0018F720 +4 b = 200 : 0x0018F724 +4 c = 300 : 0x0018F728
// LLVM Clang 下编译结果 a = 100 : 0x7fff547d59ec -4 b = 200 : 0x7fff547d59e8 -4 c = 300 : 0x7fff547d59e4
C程序在执行的时候，先入栈的数据是在栈底的，栈底是高地址，后入栈的数据在栈顶，栈顶为低地址。
从上面的例子看得出来: GCC和MSVC下，参数的进栈顺序是"从右往左"。 在LLVM Clang下，参数的进栈顺序是"从左往右"。
3. 函数参数的计算顺序
//1. #include <stdio.h> int main(void) { int a = 10, b = 20, c = 30; printf("%d, %d, %d\n", a + b + c, b = b * 2, c = c * 2); return 0; }
// Windows Visual C++ 下编译结果 110, 40, 60
// Ubuntu GCC 下编译结果 110, 40, 60
// LLVM Clang 下编译结果 60, 40, 60
//2. #include <stdio.h> int a() { printf("a\n"); return 1; }
int b() { printf("b\n"); return 2; }
int main(void) { printf("%d, %d\n", a(), b()); return 0; }
//MSVC 下编译结果 b a 1, 2
// Ubuntu GCC 下编译结果 b a 1, 2
// LLVM Clang 下编译结果 a b 1, 2
4. 函数的默认参数
#include <stdio.h> void func(int a, int b, int c = 300) // 三个形参（本质是局部变量），接收实参的值 { printf("a = %d : %p", a, &a); printf("b = %d : %p", b, &b); printf("c = %d : %p", c, &c); }
int main(void) { func(100, 200); // 三个实参 return 0; }
上面的写法，在LLVM Clang下是可以编译通过的，而且c的值是300，func(100, 200)的值也给了a 和 b。 但是在 MSVC 和 GCC下不允许这么做，也不允许在函数参数列表里赋值。
C编译器： Microsoft Visual C++ / GNU GCC /LLVM Clang / ICC / Turbo C
当一个函数的参数列表里有多个参数的时候，C语言没有规定实参的进栈顺序和计算顺序，而是由编译器自行决定的。
我们在写代码的时候，尽量不要写出UB(行为未定义、奇葩)语句：
"Undefined Behavior"简单来说就是： 如果你的程序违反了C标准中某些规则，程序具体执行结果会发生什么，C语言没有定义。 也就是说得到的结果可能是某种奇怪的情况，都是有可能发生的。 比如说，整数溢出就是一个"Undefined Behavior"语句。
"Unspecified Behavior"简单来说就是： C标准提供了好多种可选方案，但是没有告诉你一定要用哪一种， 比如说，函数参数的计算顺序就是这种情况。
三、一级指针 1. 指针的使用： 32位系统下是 4 个字节，64位系统下是 8 个字节
1） 在定义的时候用 * 号，代表这个变量那个是指针类型 int a = 10; // 定义一个整型变量，存储整数 10 int *p = &a; // 定义一个整型指针变量，存储a的地址
2） 在配合表达式使用 * 号，代表取值运算符，可以取出这个地址里的值 printf("%d\n", *p); // 打印p指向的地址里的值 printf("%d\n", *(&a)); // 打印a这个地址里的值 printf("%d\n", *p + 1); // 取出值，再加1打印出来
2. 指针的几种特殊定义方式： 1) int * const p; 指针常量：p 是 int*类型，那么const修饰的是p，所以p是常量，表示p指向的地址不可修改， 也就是说，p不能再指向别的地方了，但是可以修改p指向的这个地址里的值。 举例： int a = 10; int b = 20; int * const p = &a; p = &b; // 错误 *p = 100; // 允许
2) const int *p; int const *p; 常量指针：p 是 int*类型，那么const修饰的是*p，所以*p是常量，表示p指向的地址里的值不可修改， 也就是说，p里的值不能再重新赋值了，但是可以修改p指向的地址。 int a = 10; int b = 20; const int *p = &a; p = &b; // 可以 *p = 100; // 错误
3) const int * const p; 常量指针常量：p 是 int*类型，那么const分别修饰了p 和 *p， 所以p和*p都是常量，表示p指向的地址不可修改， 同时p指向的地址里的值也不可修改。 int a = 10; int b = 20; const int *const p = &a; p = &b; // 错误 *p = 100; // 错误
《C Primer Plus》 ： "自由的代价，是永远的警惕。" 你定义了一个指针，那就一定要知道这个指针指向的什么地方，而且你要保证这个指针是真实有效的，否则我就用程序崩溃来惩罚你。
四、多级指针
#include <stdio.h> int main(void) { int a = 10; int *p = &a; // 定义一个一级指针变量，存储了整型变量a的地址 int **pp = &p; // 定义一个二级指针变量，存储了整型一级指针变量p的地址 int ***ppp = &pp; // 定义了一个三级指针变量，存储了整型二级指针变量pp的地址
printf("%p, %p, %p, %p\n", &a, &p, &pp, &ppp); // 分别打印各个变量自身所在的内存地址
printf("%p, %p, %p, %p\n", &a, p, pp, ppp); //printf("%d", a); 用%d的形式打印a的值：整数 //printf("%p", p); 用%p的形式打印p的值：地址 // &a : 打印 变量 a 的地址 // p： 打印变量 a的地址 // pp: 打印变量 p 的地址 // PPP：打印变量 pp 的地址
printf("%p, %p, %p, %p\n", &a, p, *pp, **ppp); // &a : 打印 变量 a 的地址 // p： 打印变量 a 的地址 // *pp：打印变量 a 的地址 //**PPP: 打印变量 a 的地址
printf("%d, %d, %d, %d\n", a, *p, **pp, ***ppp); // a: 打印 10 // *P: 打印 10 // **pp：打印 10 // ***ppp: 打印 10 }
五、指针 和 数组的用法
int num[5] = {10, 20, 30, 40, 50}; int *p = num;
打印的值 打印后*p的值是 数组里的原值 // 操作地址 *p++ 10 20 10 *(p++) *和++的优先级相同，根据结合性（从右往左），那么p先和后自增运算符++结合， ++操作将在表达式完成后进行自增，也就取出p指向的值之后，p指向的下标后移一位(4个字节)。
*++p 20 20 10 *(++p) *和++优先级相同，根据结合性（从右往左），那么p先和前自增运算符++结合， ++操作将会立即完成，p指向的下标后移一位(4个字节)，然后再取出p指向的值。
// 操作数值 (*p)++ 10 11 11 根据优先级()小括号优先级最高，p先和*相结合，然后再和后自增运算符++结合， 因为是后自增，所以先打印当前下标的值，然后在原值的基础上自增 1，此时原值已被改变
++*p 11 11 11 ++(*p) 根据结合性/优先级，*和p先结合，然后再和前自增运算符++结合， 因为是前自增，所以先在原值的基础上自增1，然后在打印这个值，此时原值已被改变。
总结：如果一个表达式里有多个运算符，则先进行优先级比较，先执行优先级高的运算符； 如果优先级相同，那就看结合性，根据结合方向来做运算。
结合性： 从左往右： 小括号()、数组括号[]、成员选择 . 和 ->，双目运算符，逗号运算符
从右往左： 单目运算符、三目运算符、赋值类运算符
/* ++a: 是直接从变量 a 所在的内存地址中取值，并进行加1操作，再执行表达式剩余部分。 a++： 先把变量的值保存在一个临时寄存器里，然后再执行整个表达式，执行完之后，再把a的值自增1，再返回内存里。
CPU -》 寄存器 -》 缓存(L1\L2\L3) -》 来自于内存 CPU只和寄存器做数据交换，对于重复操作的数据会放在缓存里。 但是不管寄存器还是缓存，他们的数据都来自于内存。 */
六、指针数组 和 数组指针
1. 指针数组： 定义形式： int *p[n] = { 0 }; []的优先级高于*，那么p先和[]结合，说明这是一个数组。 再和int *结合，说明这个数组里的每个元素都是一个指针，每个元素都能保存一个地址。
1) 使用指针数组保存多个数据的地址 int main(void) { int a[3] = { 10, 20, 30}; int *p[3] = { 0 }; for (int i = 0; i < 3; ++i) p[i] = &a[i];
for (int i = 0; i < 3; ++i) { printf("%p\n", p[i]); printf("%d\n", *p[i]); } }
2) 使用指针数组保存多个字符串的首地址 #include <stdio.h>
int main(void) { char *str[5] = { "ISO/IEC9899:2011", "Programming", "Dennis Ritchie", "c", "bell ssss" };
char *str1 = str[1]; // 取出 第2行的字符串 char *str2 = *(str + 3); // 取出 第4行的字符串 char ch1 = *(*(str + 4) + 2); //取出 第5行的字符串的第3个字符 char ch2 = (*str + 5)[7]; // 取出第1个字符串的第6个字符，并以此做数组首元素，向后遍历到第7个。 char ch3 = *str[0] + 6; // 取出第1个字符串的第1个字符，然后把这个字符ASCII码加上6，再用%c打印出来
printf("str1 = %s\n", str1); // Programming printf("str2 = %s\n", str2); // c printf("ch1 = %c\n", ch1); // l printf("ch2 = %c\n", ch2); // 2 printf("ch3 = %c\n", ch3); // O （不是0）
return 0; }
2. 数组指针（行指针） 定义形式： int *p; int (*p)[n]; int (*p)[n][m]; ()和[]的优先级相同，但是结合性是从左往右，那么p先和*相结合，说明这是一个指针。 然后再和[]结合，说明这个指针指向了一个数组。
示例： 1) #include <stdio.h>
void func(int (*p)[3], int n); int main(void) { int a[2][3] = {10, 20, 30, 40, 50, 60}; // 行： 0 1 // 列： 0 1 2 0 1 2 func(a, sizeof(a)); return 0; }
void func(int p[2][3], int n); // 明确行和列的数量
void func(int p[][3], int n); //明确列的数量
void func(int (*p)[3], int n) //明确列的数组指针 { printf("%d\n", p[1][2]); // 取出第2行的第3个元素：60
printf("%d\n", **p); //p是行指针，先是取出当前行的列地址，再取出这个列地址里的值： 10
printf("%d\n", (*p + 1)[2]); // 先取出列地址，然后往后移动一个int(4个字节),再以这一列的下标为起点，取出后面第2个元素的值：40
printf("%d\n", *(*p + 1)); // 先取出列地址，往后移动1位(1个int)，再取出这个下标的值：20
printf("%d\n", *(p[1] + 2)); // 先取出p[1]的列下标地址，再往后移动2位(2个int),再取出这个下标的值：60
printf("%d\n", *(*(p + 1))); // 先将行指针p后移一位(3个int)，再取出这一行的这一列的下标地址，再根据这个下标取值：40
printf("%d\n", *((*p + 1) + 2)); //这个表达式相当于 *(*p + 3)，先取出列下标地址，然后往后移动3位（3个int），再取值：40
printf("%d\n", *(*p + 1) + 2); // 先取出列下标的地址，然后往后移动一位(1个int)，再进行取值得出20，再加2，结果是：22
}
// 三维数组同理 void func(int (*p)[3][4]) { printf("%d\n", *(*(*(p + 0) + 1 ) + 2); //70 }
int main(void) { int a[2][3][4] = { {{10, 20, 30, 40}, {50, 60, 70, 80}, {90, 100, 110, 120}}, {{11, 22, 33, 44}, {55, 66, 77, 88}, {99, 101, 111, 121}} };
func(a); return 0; }
总结： 1.指针数组：就是一个数组，这个数组里的每个元素都是一个指针，这个数组在内存空间中占用了n个指针的大小。
2.数组指针：就是一个指针，这个指针指向一个数组，这个指针在内存空间中占用一个指针的大小。
3.二级指针p 和 二维数组名p 的区别： int **p; 这个是一个整型的二级指针，p是一个可变句柄/钥匙，我们可以让这个指针指向任何我们希望它指向的地方。 这个句柄不需要指定内存空间的大小。 int p[n][m]; 这个是一个整型的二维数组，p是引用了这块内存空间的句柄/钥匙，数组在定义的时候， 就被固定指向某个内存空间了，这个空间大小是 sizeof(int) * n * m，而且不可修改p的指向， p就是一个不可变的常量，永远的都只能指向这里了。
如果想确定某个一维数组的值： * 、 [] 如果想确定某个二维数组的值：** 、 [][] 、 *[]
七、内存四区
stack: 栈区，是由编译器自动分配和释放，主要是存放函数参数的值，局部变量的值。
heap：堆区，是由程序员自己申请分配和释放，需要 malloc(); calloc(); realloc();函数来申请，用free()函数来释放 如果不释放，可能出现野指针。
**函数不能返回指向栈区的指针，但是可以返回指向堆区的指针。**
data：数据区 -> 静态（全局）区 和 常量区 静态（全局）区：标有 static 关键字，保存了静态变量和全局变量 1. 初始化的全局变量和初始化的静态变量，在一块区域； 2. 未初始化的全局变量和未初始化的静态变量，在一块区域； 3. 静态变量的生命周期是整个源程序，而且只能被初始化一次，之后的初始化会被忽略。 （如果不初始化，数值数据将被默认初始化为 0, 字符型数据默认初始化为 NULL ）。
常量区：这里的数据是只读的，常量和字符串都保存在这里。(不包括字符数组类型的字符串 -> 栈区) 除了第一次初始化外，常量区的数据在程序执行的时候不允许再次赋值。
整个数据区的数组，在程序结束后由系统统一销毁。
code：代码区，用于存放编译后的可执行代码，二进制码，机器码。
static 关键字详解： static 在C语言里面既可以修饰变量，也可以修饰函数。
static 变量： 1. 静态局部变量：在函数中定义的，生命周期是整个源程序，但是作用域和自动变量没区别。 都是只能在定义这个变量的函数范围内使用，而且只能在第一次进入这个函数时候被初始化， 之后的初始化会跳过，并保留原来的值。退出这个函数后，尽管这个变量还在，但是已经不能使用了。
2. 静态全局变量：全局变量本身就是静态存储的，但是静态全局变量和非静态全局变量又有区别： 1) 全局变量：变量的作用域是整个源程序，其他源文件也可以使用，生命周期整个源程序。 2) 静态全局变量：变量的作用域范围被限制在当前文件内，其他源文件不可使用，生命周期整个源程序。
static 函数（内部函数）： 只能被当前文件内的其他函数调用，不能被其他文件内的函数调用，主要是区别非静态函数(外部函数)
总结： 作用域：变量或函数在运行时候的 有效作用范围 。 生命周期：变量或函数在运行时候的 没被销毁回收 的存活时间。
作用域 生命周期
局部变量 所在代码块内 所在函数结束
全局变量 所有文件内 程序执行结束
静态局部变量 所在代码块内 程序执行结束
静态全局变量 当前文件内 程序执行结束
普通函数 所有文件内 程序执行结束
静态函数 当前文件内 程序执行结束
八、堆区内存
#include <stdlib.h>
1. void* malloc(n * sizeof(int)); 请求 n 个连续的、每个长度是一个int大小的堆空间，如果创建成功，将返回这个堆空间的首地址，如果创建失败，返回 NULL;
2. void* calloc(n, sizoef(int)); 请求 n 个连续的、每个长度是一个int大小的堆空间，如果创建成功，将返回这个堆空间的首地址，如果创建失败，返回NULL ; (和 malloc() 函数的区别在于，calloc()在创建成功后，会把空间自动初始化为 0 );
3. void *realloc(p, n * sizeof(int)); 给一个已经分配了地址的指针 p 重新分配空间，p 是原来空间的首地址，n * sizeof(int) 基于这个首地址重新分配的大小; 1) 如果当前内存段后面有足够的内存空间，那么就直接扩展这段内存，realloc()返回原来的首地址; 2) 如果当前内存段后面没有足够的内存空间，那么系统会重新向内存树申请一段合适的空间，并将原来空间里的数据块释放掉， 而且 realloc() 会返回重新申请的堆空间的首地址; 3) 如果创建失败，返回 NULL, 此时原来的指针依然有效;
4. void free(); 1) free(p); 只是释放了申请的内存，系统将这块内存标记为可用。也就是可以被其他进程使用，但是并不改变 p 的指向; 2) p 所指向的内存空间被释放，所以其他程序就有机会使用这段空间了，相当于 p 指向了不属于自己的空间，里面的数据也是未知的。 （这个就叫野指针） 3) 为了避免野指针，最好在 free(p)之后，将 p = NULL; void *(0); 4) free()函数在执行的时候，其实是把这个块内存返回了内存红黑树上，让别人可以使用这块内存。 从逻辑上来说，释放p之后，你是不能再访问原先p指向的这块内存了，但是现在操作系统没有做到， 所以你还是可以访问到这块内存的，只是里面可能存有的数据不属于你。 free(p)之后，其实系统并没有做数据清空处理，所以你既可以访问这个空间，也可以用里面的值。 但是严格意义上来说，这样做是非法的！会造成野指针！
示例： // 如何释放自定义函数内申请的堆空间 #include <stdio.h> #include <stdlib.h> #include <string.h>
char *funcA(); char *funcB();
int a = 10; // 全局 初始化区域 char *p1; // 全局 为初始化区域
int main(void) { int b; // 栈区 char arr[] = "hello"; // 栈区 char *p2; // p2 在栈区 const char *p3 = "world!"; // p3 在栈区，"world!\0" 在常量区
static int c = 0; // 静态区 初始化区域
char *p;
p1 = (char *)malloc(20); // p1 指向堆区 20个字节
memset(p1, 0, sizeof(char) * 20); // 使用memset()函数将内存空间初始化为 0 strcpy(p1, "Are you Sleep?"); // "Are you Sleep?" 是在常量区
printf("%s\n", p1); // p1 指向的 拷贝到堆空间的 "Are you Sleep?" 的首地址，通过首地址打印这个字符串
p2 = funcB(); // p2 接收了funcB()回传堆空间首地址，可以通过这个地址找到funcA()申请的堆空间
free(p2); // 也可通过 p2 释放 自定义函数里申请的对空劲啊 free(p1);
p1 = NULL; // 安全起见，释放堆空间指针后， 重置将指针变量置为 NULL p2 = NULL;
return 0; // 返回 0 给系统表示 main()正常执行结束，也就代表程序执行结束 }
char *funcA() { int a = 10; const char *pa = "1234567"; // pa 在栈区， "1234567\0" 在常量区 char *pb = NULL; // pb 在栈区，pb 占4字节(32bit system)
pb = (char *)malloc(20); // pb 指向了一个20个字节大小的堆空间 strcpy(pb, "Yes, I'm!"); // 拷贝 字符串给 pb，"Yes, I'm!\0" 在常量区
return pb; // 返回 指针变量 pb 保存的堆空间首地址给调用函数funcB() }
char *funcB() { char *pa = NULL; // pa 是一个栈上的指针变量 pa = funcA(); // pa 接收了 funcA()函数返回的堆空间地址 return pa; // 返回指针变量 pa 保存的堆空间首地址给调用函数 main(); }
论空间分配速度： 栈区确实略快于堆区， 使用栈的时候，是直接从分配的地址里读取值，放到寄存器里，然后再放到目标地址。 使用堆的时候，是先将分配的地址放到寄存器里，然后再从这个地址里取值，再放到寄存器里，再放到目标地址。
论空间访问速度： 栈区和堆区是一样的，都是一个直接寻址的过程，没有区别。
CPU -> 寄存器 > L1 > L2 > L3 (属于缓存) > RAM(内存) > ROM(主板的存储器) > 硬盘 CPU 只和 寄存器做数据存取，寄存器是用来存储临时数据的，对于需要重复操作的数据，会放到缓存里。 不管是寄存器还是缓存，数据都来自于内存， 内存呢又分为四个区....
九、文件操作;
数据I/O流
#include <stdio.h>
1 fopen()函数：打开文件 函数原型：FILE *fopen(char restrict *filename, char restrict *mode); // restrict C99标准才引进的，属于类型修饰符，表示修饰的这块内存空间只能被这个指针引用和修改，除此之外别无他法。
参数： filename: 需要打开的文件 mode: 文件打开方式
r 以只读的方式打开文件，前提是这个文件必须存在（只写 r 默认是文本文件） r+ 以可读可写的方式打开文件，前提是这个文件必须存在(默认是文本文件)。 rb 以只读的方式打开一个二进制文件，前提是这个文件必须存在。 rb+ 以可读可写的方式打开一个二进制文件，前提是这个文件必须存在。
w 以只写的方式打开文件，如果这个文件不存在，就创建这个文件；如果这个文件存在，则清空内容。 w+ 以可读可写的方式打开文件，如果这个文件不存在，就创建这个文件；如果这个文件存在，则清空内容。 wb 以只写的方式打开一个二进制文件，如果这个文件不存在，就创建这个文件；如果这个文件存在，则清空内容。 wb+ 以可读可写的方式打开一个二进制文件，如果这个文件不存在，就创建这个文件；如果这个文件存在，则清空内容。
a 以追加的方式打开只写文件，如果这个文件不存在，就创建这个文件；如果这个文件存在，则在文件尾部追加内容。 a+ 以追加的方式打开一个可读可写的文件，如果这个文件不存在，就创建这个文件；如果这个文件存在，则在文件尾部追加内容。 ab 以追加的方式打开一个二进制只写文件，如果这个文件不存在，就创建这个文件；如果这个文件存在，则在文件尾部追加内容。 ab+ 以追加的方式打开一个二进制可读可写文件，如果这个文件不存在，就创建这个文件；如果这个文件存在，则在文件尾部追加内容。
r(read): 读; w(write):写; a(append)：追加; +(plus):读或写，主要是配合r、w、a使用; t(text):文本文件; b(binary)：二进制文件
返回值：如果文件顺利打开，则返回值是指向这个文件流的文件指针， 如果文件打开失败，返回 NULL (void*)0
一般来说，文件打开失败会做一个文件指针错误判断 FILE *fp = fopen("c:\\code\\text.c", "w+"); if(NULL == fp) { //code //exit(-1); }
2 fgetc(); 和 fputc(); 1) fgetc() 文件字符读取函数 原型： int fgetc(FILE * stream); 参数： stream： 文件流 返回值： 成功返回获取的字符ASCII码，失败返回 EOF(-1); 举例： char ch = fgetc(fp); // 从fp指向的文件流里接收文件流里的第一个字符
2) fputc() 文件字符写入函数 原型： int fputc(int ch, FILE * stream); 参数： ch ：就是写入的字符，函数在执行的时候，会自动把 ch ASCII码 转换成一个 unsigned char 类型。 stream: 文件流 返回值： 成功返回输出的字符，失败返回 EOF(-1); 举例： fputc(ch, fp); // 把字符ch写入到 fp 所指向的文件流里。
3 fgets(); 和 fputs(); 1) fgets() 读取文件字符串函数 原型：char *fgets(char *str, int size, FILE* fp); 参数： str : 保存从fp指向的文件流里读取的一行字符串。 size: 从文件流里读取的字符串不超过 size 个字符。( 一般会使用size - 1，留一个字符位置给 '\0') fp : 文件指针 返回值：成功返回读取的字符串所在的内存首地址，失败返回 EOF(-1); 举例： char str[20] = { 0 }; fgets(str, 20 - 1, fp); // 从fp指向的文件流的第一行里读取 19个字符，然后放到字符数组 str里。
2) fputs() 写入文件字符串函数 原型：fputs(char *str, FILE* fp); 参数： str: 要写入到文件里字符串 fp: 文件指针 举例： char str[20] = "Hello Kitty!"; fputs(str, fp); // 向 fp 指向的文件流里写入一个字符串 str，具体怎么写，看 mode 属性。
4 fprintf(); 和 fscanf(); 1) fprintf() 将格式化后的数据写入到文件流里 原型： int fprintf(FILE *stream, char *format, argument...); 举例： int i = 10; float f = 3.14; char ch = 'C'; char str[10] = "haha"; fprintf(fp, "%d %f %c %s\n", i, f, ch, str); // 将各个数据按格式写入到文件流里
2) fscanf() 从文件流里获取数据格式化写入输入流里 原型： int fscanf(FILE *stream, char *format, argument... ); 举例： int i; float f; char ch; char str[10]; fscanf(fp, "%d,%f", &i, &f); // 如果不需要从文件里面写入字符串，那么就可以用逗号或者其他符号来分隔
fscanf(fp, "%s%c", str, &ch); // 如果文件里需要写入字符串，那么字符串与其他数据之间只能用空格和回车来分隔
5 fread(); 和 fwrite(); 二进制文件读写函数 函数原型： size_t fread(void *ptr, size_t size, size_t count, FILE* fp); size_t fwrite(void *ptr, size_t size, size_t count, FILE* fp); 参数： ptr: 是一个指针，对应 fread()来说，是从文件里读入的数据存放的地址; 对应 fwrite()来说，是写入到文件里的数据存放的地址。 size: 每次要读写的字节数 count : 读写的次数 fp: 文件指针
返回值： 成功读取/写入的字节数
举例： char str[] = { 0 }; fread(str, sizeof(char) * 10, 1, fp); // 每次从fp指向的文件中读取10个字节大小，放入字符数组 str 中，总共读1次 fwrite(str, sizeof(char) * 10, 1, fp); // 每次从str里获取 10个字节大小，写入到 fp 指向的文件中，总共写1次
6 fseek(); 文件指针操作函数 函数原型： size_t fseek(FILE* fp, long offset, int whence); 参数： fp ： 文件指针 offset: 偏移量，基于起始点偏移了 offset 个字节 whence : 起始点（三个）： SEEK_SET 0 文件开头位置 SEEK_CUR 1 当前位置 SEEK_END 2 文件结尾位置
举例 fseek(fp, 0, SEEK_END); // 将文件指针指向文件结尾，并偏移了 0 个字节，也就是直接将文件指针指向文件结尾 fseek(fp, -10, SEEK_CUR); // 将文件指针指向当前位置，并偏移了 -10 个字节，也就是将文件指针往前移动10个字节
7 ftell(); 文件指针操作函数 函数原型： long ftell(FILE* fp); 参数： fp 文件指针 返回值：返回文件指针当前位置，基于文件开头的偏移字节数，
举例： long len = ftell(fp); // 返回文件指针当前位置，基于文件开头的偏移字节数，保存到 len 里。
8 rewind(); 文件指针操作函数 函数原型： void rewind(FILE* stream); 参数： fp 文件指针
举例： rewind(fp); // 将文件指针重新指向I/O流（文件流）的开头。
stream > istream / ostream -> fstream -> sstream
6\7\8 大例子
FILE *fp = fopen("C:\\code\\a.txt", "r+"); fseek(fp, 0, SEEK_END); // 将文件指针指向文件结尾 long len = ftell(fp); // 获取文件指针位置，得到文件的大小(Byte) rewind(fp); // 将文件指针重新指向文件开头
9 fflush(); 清空数据流里的数据
函数原型： void fflush(FILE* stream); 参数： stream 数据流
举例： fflush(fp); // 清空文件流 fflush(stdin); // 清空输入流 fflush(stdout); // 清空输出流
10 rename(); 和 remove();
rename(FILE* filename1, FILE* filename2); 重命名文件 rename("old_name.txt", "new_name.txt"); // 把old_name.txt 重命名为 new_name.txt
remove(FILE* filename); remove("C:\\code\\a.txt"); // 将 绝对路径下的 a.txt 文件删除
11 feof(); 原型： int feof(FILE* fp); 参数： fp 文件指针 返回值： 一旦文件指针指向文件结尾，就返回一个真值；否则返回非真值(0)
1. 这个函数达到文件结尾的时候，返回的是一个真值，所以在做判断的时候要注意 !feof(fp) 2. 这个函数必须对文件进行过一次读写操作才会生效，也就是说哪怕这个文件是空的，也必须读写一次，feof()才会返回真值。 文件结束是一个标识符，每次对文件读写都会修改这个标识符的位置，对文件读写一次，文件标识符才会被找到，feof()做出返回操作。
12 fclose(); 原型： int flcose(FILE* fp); 参数： fp 文件指针 返回值： 如果成功释放，返回 0， 否则返回 EOF(-1);
fclose(fp); 表示释放文件指针和相关的文件缓冲区，文件指针不再合法指向那块区域，但是不代表清空对应的区域。
UTF-8 编码格式下 一个汉字 3 个字节 GBK 编码格式下 一个汉字 2 个字节
// UTF-8 下 汉字逆置原理 #include <stdio.h> #include <stdlib.h> #include <string.h>
int main(void) { char str[] = "基尔加丹"; int len = strlen(str);
for (int i = len - 1; i > 0; i -= 3) // UTF-8 编码下是3个字节，GBK下是2个字节 { printf("%c%c\n", str[i - 1], str[i]); } // printf("%c%c\n", str[0], str[1]); // 打印"基"
return 0; }
不同操作系统的行尾标志： CR LF \ CR \ LF
CR 是 '\r' 回车 LF 是 '\n' 换行
在DOS和NT内核的Windows下，采用的是 回车+换行(CR LF '\r''\n') 来表示下一行的开始 在Unix/Linux下，采用的是 换行(LF '\n') 来表示下一行的开始 在Macintosh下(OS X) ，采用的是 回车(CR '\r') 来表示下一行的开始
十、结构体
1. 结构体的字节对齐： 在C语言里，结构体所占的内存是连续的，但是各个成员之间的地址不一定是连续的。所以就出现了"字节对齐".
结构体变量的大小，一定是其最大的数据类型的大小的整数倍，如果某个数据类型大小不够，就填充字节。 结构体变量的地址，一定和其第一个成员的地址是相同的。
1) 结构体字节对齐 #include <stdio.h> #include <string.h>
struct Box { int height; // 高 char a[10]; double width; // 宽 char type; // 类型 };
int main(void) { struct Box box; box.type = 'C'; // C 类型 strcpy(box.a, "hahaha"); box.height = 4; // 高度是 4 box.width = 5.5; // 宽度是 5.5
printf("box = %p\n", &box); printf("box.height = %p\n", &box.height); printf("box.a = %p\n", box.a); printf("box.width = %p\n", &box.width); printf("box.type = %p\n", &box.type);
printf("box = %d\n", sizeof(box)); return 0; }
2) 初识链表 #include <stdio.h> #include <string.h> #include <stdlib.h>
struct Student { char *name; // 姓名 int age; // 年龄 struct Student *next; // next 是结构体成员，但是类型是 struct Student * 类型，用来指向某个 struct Student 的结构体变量的。 // 结构体可以看做是一个自定义的数据类型，而且结构体可以嵌套，但是嵌套有条件： // 结构体只可以嵌套自身类型的结构体指针，但是绝对不能嵌套自身类型的结构体变量 // 比如，不能嵌套 struct Student next; 这种 };
int main(void) { struct Student stu, *stup; // 定义了一个结构体变量 stu 和 一个结构体指针变量 stup
stu.name = (char *)malloc(10 * sizeof(char)); // 给姓名申请了一个10个字节的堆空间 strcpy(stu.name, "damao"); // 拷贝字符串 "damao" 给 stu.name (注意，不能直接赋值，要用拷贝) stu.age = 18; // 今年 18岁了
stup = (struct Student *)malloc(1 * sizeof(struct Student)); // 给 stup 申请一个堆空间，用来保存两个指针(name,next)和一个int stup->name = (char *)malloc(10 * sizeof(char)); // 给 stup->name 申请一个堆空间，保存字符串 strcpy(stup->name, "ermao"); // 拷贝字符串 stup->age = 16; // 今年 16岁了
stu.next = stup; // stu的成员next 指向了 结构体变量 stup 的首地址，链表诞生 stup->next = NULL; // stup的成员 next 指向 NULL， 保证安全。
free(stup->name); // 最后申请的堆 最先释放 free(stup); // 继续释放 free(stu.name); // 最先申请的堆 最后释放
return 0; // 程序正常结束 }
End...
