十、数据存储与内存管理
1.1 整型在内存中的存储
1.1.1 原码、反码、补码
1. 计算机中的整数有三种表示方法，即原码、反码和补码。三种表示方法均有符号位和数值位两部分，符号位都是用0表示“正”，用1表示“负”，而数值位
2.
计算机用反码，是为了做减法可以用硬件（集成电路）加法器实现。
正数加正数，不用变化，直接送入加法器。
正数加负数：
正数减一个数，等于加原数的负数，等于加它的反码。
负数才有反码。负数才需要有反码。
正数没有反码，或不需要反码。为了定义上的完整，约定：正数的反码和其源码相同。
3.
原码: 直接将二进制按照正负数的形式翻译成二进制就可以。
反码: 将原码的符号位不变，其他位依次按位取反就可以得到了。
补码: 反码+1就得到补码。
3. 整型在内存中存储的都是七对应的补码:
在计算机系统中，数值一律用补码来表示和存储。原因在于，使用补码，可以将符号位和数值域统
一处理；同时，加法和减法也可以统一处理（CPU只有加法器）此外，补码与原码相互转换，其运算过程
是相同的，不需要额外的硬件电路。
如: 20
原码: 00000000 00000000 00000000 00010100
反码: 00000000 00000000 00000000 00010100
补码: 00000000 00000000 00000000 00010100 00 00 00 14
-10
原码: 10000000 00000000 00000000 00001010
反码: 11111111 11111111 11111111 11110101
补码: 11111111 11111111 11111111 11110110 ff ff ff f6
1.1.2 大小端存储
1.1.2.1 什么是大小端存储
大端（存储）模式，是指数据的低位保存在内存的高地址中，而数据的高位，保存在内存的低地址
中；
小端（存储）模式，是指数据的低位保存在内存的低地址中，而数据的高位,，保存在内存的高地
址中。
这是因为在计算机系统中，我们是以字节为单位的，每个地址单元都对应着一个字节，一个字节为8bit。但是在C语言中除了8 bit的char之外，还有16 bit的short型，32 bit的long型（要看具体的编译器），另外，对于位数大于8位的处理器，例如16位或者32位的处理器，由于寄存器宽度大于一个字节，那么必然存在着一个如何将多个字节安排的问题。因此就导致了大端存储模式和小端存储模式。
例如：一个 16bit 的 short 型 x ，在内存中的地址为 0x0010 ， x 的值为 0x1122 ，那么 0x11 为
高字节， 0x22 为低字节。对于大端模式，就将 0x11 放在低地址中，即 0x0010 中， 0x22 放在高地址中，即 0x0011 中。小端模式，刚好相反。我们常用的 X86 结构是小端模式，而 KEIL C51 则为大端模式。很多的ARM，DSP都为小端模式。有些ARM处理器还可以由硬件来选择是大端模式还是小端模式。
// 1. 编写代码，判断电脑是大端存储还是小端存储 #define _CRT_SECURE_NO_WARNINGS 1 #include<stdio.h> int check_sys() { int a = 1; // 00000000 00000000 00000000 00000001 char *p = (char *)&a; //char *p = (char *)&a; 取int类型第一个字节,如果第一个字节的值是 1 说明低地址存数据低位，就是小端存储， (char *)强制类型转换 return *p; } int main() { int ret = check_sys(); printf("ret = %d\n", ret); if (ret == 1) { printf("小端存储\n"); } else { printf("大端存储\n"); } return 0; }
// 2. 下面输出结果是多少？ #define _CRT_SECURE_NO_WARNINGS 1 #include<stdio.h> int main() { char a = -1; /* -1: 原码 10000000000000000000000000000001 反码 11111111111111111111111111111110 补码 11111111111111111111111111111111 char 类型 1个字节， 小端存储 取补码最后1个字节,8位 11111111 此时 char默认第一位是符号位 采用 %d输出， 高位补位与符号位相同，有符号数按符号数补充，无符号数直接补零 11111111111111111111111111111111 所以 char a = -1。 在内存中的按照 %d取值取到的是 补码为 11111111111111111111111111111111 的值，也就是 -1 */ signed char b = -1; // 同上 unsigned char c = -1; // 000000000 00000000 00000000 11111111 无符号数直接补零 printf("a = %d, b = %d, c = %d\n", a,b,c); // -1 -1 255 return 0; }
// 3. 下面输出结果是多少？ #define _CRT_SECURE_NO_WARNINGS 1 #include<stdio.h> int main() { char a = -128; /* -128 原码: 10000000 00000000 00000000 10000000 反码: 11111111 11111111 11111111 01111111 补码: 11111111 11111111 11111111 10000000 char: 取值: 10000000 高位补齐: 11111111 11111111 11111111 10000000 %u输出， 无符号位 原码即为补码，所以就是 11111111 11111111 11111111 10000000 4294967168 */ printf("%u\n", a); // 4294967168 return 0; }
// 4. 下面输出结果是多少？ #define _CRT_SECURE_NO_WARNINGS 1 #include<stdio.h> int main() { char a = 128; printf("%u\n", a); // 4294967168 原理同上 return 0; }
// 5. 下面输出结果是多少？ #define _CRT_SECURE_NO_WARNINGS 1 #include<stdio.h> int main() { int i = -20; // 10000000 00000000 00000000 00010100 unsigned int j = 10; // 00000000 00000000 00000000 00001010 //-20原码 10000000 00000000 00000000 00010100 //-20反码 11111111 11111111 11111111 11101011 //-20补码 11111111 11111111 11111111 11101100 // 10原码 00000000 00000000 00000000 00001010 // 相加 11111111 11111111 11111111 11110110 //取反码 11111111 11111111 11111111 11110101 //取原码 10000000 00000000 00000000 00001010 -10 printf("%d\n", i+j); // -10 return 0; }
// 6. 下面输出结果是多少？ #define _CRT_SECURE_NO_WARNINGS 1 #include<stdio.h> int main() { unsigned int i; for (i = 9; i >= 0; i--) { printf("%u\n", i); // 9 8 7 ... 然后很大的额数死循环，因为无符号，-1也在内存中是特别大的数，会一直运行下去 } }
// 7. 下面输出结果是多少？ #define _CRT_SECURE_NO_WARNINGS 1 #include<stdio.h> int main() { char a[1000]; int i; for (i = 0; i<1000; i++) { a[i] = -1 - i; } // a[0] == -1 10000000 00000000 00000000 00000001 // a[1] == -2 10000000 00000000 00000000 00000010 // ... // a[999] = -999 10000000 00000000 00000011 11100111 // 因为 有符号 char类型的范围是 -128 -- 127，所以 a[129]以后的数字是没办法存储下来的 // -129 10000000 00000000 00000000 10000001 这些数字是从 -1 --- -128，再往后是一个循环 // 这个循环是从 127开始，所以 -129就是 127，然后 126， 125 ... 1, 0。 又因为 求的是 strlen(a), // 只有字符串遇到 \0 的时候才停止， 也就是遇到 0 的时候停止， 从上面过来， 0之前一共有 255个数 printf("%d\n", strlen(a)); // 255 return 0; }
// 8. 下面输出结果是多少？ #define _CRT_SECURE_NO_WARNINGS 1 #include<stdio.h> unsigned char i = 0; int main() { for (i = 0; i <= 255; i++) { printf("hello world\n"); // 死循环 因为 char 的范围是 0 -- 255,始终增加，最终循环都在这个for循环内。这一个和第6题得出，无符号数特别容易死循环 } return 0; }
1.2 浮点型在内存中的存储
#define _CRT_SECURE_NO_WARNINGS 1 #include<stdio.h> int main() { int n = 9; float *pFloat = (float *)&n; printf("n的值为：%d\n",n); printf("*pFloat的值为：%f\n",*pFloat); *pFloat = 9.0; printf("num的值为：%d\n",n); printf("*pFloat的值为：%f\n",*pFloat); return 0; } // 推测: 浮点型数据存储与整型不同
1.2.2 浮点型存储
1.2.2.1 存储理论
num 和 *pFloat 在内存中明明是同一个数，为什么浮点数和整数的解读结果会差别这么大？
要理解这个结果，一定要搞懂浮点数在计算机内部的表示方法。
详细解读：
根据国际标准IEEE（电气和电子工程协会） 754，任意一个二进制浮点数V可以表示成下面的形式：
(-1)^S * M * 2^E
(-1)^s表示符号位，当s=0，V为正数；当s=1，V为负数。
M表示有效数字，大于等于1，小于2。
2^E表示指数位。
举例来说：
十进制的5.0，写成二进制是 101.0 ，相当于 1.01×2^2 。
那么，按照上面V的格式，可以得出s=0，M=1.01，E=2。
十进制的-5.0，写成二进制是 -101.0 ，相当于 -1.01×2^2 。那么，s=1，M=1.01，E=2。
IEEE 754对有效数字M和指数E，还有一些特别规定。
前面说过， 1≤M<2 ，也就是说，M可以写成 1.xxxxxx 的形式，其中xxxxxx表示小数部分。
IEEE 754规定，在计算机内部保存M时，默认这个数的第一位总是1，因此可以被舍去，只保存后面的
xxxxxx部分。比如保存1.01的时
候，只保存01，等到读取的时候，再把第一位的1加上去。这样做的目的，是节省1位有效数字。以32位
浮点数为例，留给M只有23位，
将第一位的1舍去以后，等于可以保存24位有效数字。
至于指数E，情况就比较复杂。
首先，E为一个无符号整数（unsigned int）
这意味着，如果E为8位，它的取值范围为0~255；如果E为11位，它的取值范围为0~2047。但是，我们
知道，科学计数法中的E是可以出
现负数的，所以IEEE 754规定，存入内存时E的真实值必须再加上一个中间数，对于8位的E，这个中间数
是127；对于11位的E，这个中间
数是1023。比如，2^10的E是10，所以保存成32位浮点数时，必须保存成10+127=137，即
10001001。
// 1. E不全为0或不全为1 这时，浮点数就采用下面的规则表示，即指数E的计算值减去127（或1023），得到真实值，再将 有效数字M前加上第一位的1。 比如： 0.5（1/2）的二进制形式为0.1，由于规定正数部分必须为1，即将小数点右移1位，则为 1.0*2^(-1)，其阶码为-1+127=126，表示为 01111110，而尾数1.0去掉整数部分为0，补齐0到23位00000000000000000000000，则其二进 制表示形式为: 0 01111110 00000000000000000000000 // 2. E全为0 这时，浮点数的指数E等于1-127（或者1-1023）即为真实值， 有效数字M不再加上第一位的1，而是还原为0.xxxxxx的小数。这样做是为了表示±0，以及接近于 0的很小的数字。 // 3. E全为1 这时，如果有效数字M全为0，表示±无穷大（正负取决于符号位s）；
为什么 0x00000009 还原成浮点数，就成了 0.000000 ？
首先，将 0x00000009 拆分，得到第一位符号位s=0，后面8位的指数 E=00000000 ，最后23位的有效数
字M=000 0000 0000 0000 0000 1001。
9 -> 0000 0000 0000 0000 0000 0000 0000 1001
由于指数E全为0，所以符合上一节的第二种情况。因此，浮点数V就写成：
V=(-1)^0 × 0.00000000000000000001001×2^(-126)=1.001×2^(-146)显然，V是一个很小的接近于0的正数，所以用十进制小数表示就是 0.000000。
再看例题的第二部分。
请问浮点数9.0，如何用二进制表示？还原成十进制又是多少？
首先，浮点数9.0等于二进制的1001.0，即 1.001 * 2^39.0 -> 1001.0 ->(-1)^0 * 1.0012^3 -> s=0, M=1.001,E=3+127=130
那么，第一位的符号位s=0，有效数字M等于001后面再加20个0，凑满23位，指数E等于3+127=130， 即10000010。
所以，写成二进制形式， 应该是 S+E+M，即
0 10000010 001 0000 0000 0000 0000 0000
这个32位的二进制数，还原成十进制，正是 1091567616 。
二、内存管理
1. 栈区（stack）：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。 栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。
2. 堆区（heap）：一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。分配方式类似于链表。
3. 数据段（静态区）（static）存放全局变量、静态数据。程序结束后由系统释放。
4. 代码段：存放函数体（类成员函数和全局函数）的二进制代码。
实际上普通的局部变量是在栈区分配空间的，栈区的特点是在上面创建的变量出了作用域就销毁。
但是被static修饰的变量存放在数据段（静态区），数据段的特点是在上面创建的变量，直到程序
结束才销毁所以生命周期变长。
2.2 动态内存函数
2.2.1 malloc 和 free
// C 语言提供动态开辟内存的函数 void* malloc (size_t size); // 向内存申清 10 个整形的空间 int *p = (int *)malloc(10 * sizeof(int));#define _CRT_SECURE_NO_WARNINGS 1 #include<stdio.h> #include<stdlib.h> #include<string.h> int main() { // 向内存申清 10 个整形的空间 int *p = (int *)malloc(10 * sizeof(int)); if (p == NULL) { // 打印开辟空间失败的原因 printf("%s\n", strerror(errno)); } else { // 正常使用空间 int i = 0; for (i = 0; i < 10; i++) { *(p + i) = i; } for (i = 0; i < 10; i++) { printf("%d ", *(p+i)); } } return 0; }
这个函数向内存申请一块连续可用的空间，并返回指向这块空间的指针。
如果开辟成功，则返回一个指向开辟好空间的指针。
如果开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做检查。
返回值的类型是 void* ，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己
来决定。
如果参数 size 为0，malloc的行为是标准是未定义的，取决于编译器。
// C 语言提供动态释放内存的函数 void free (void* ptr); // 当动态申请的内存不再使用的时候，需要使用 free来释放空间#define _CRT_SECURE_NO_WARNINGS 1 #include<stdio.h> #include<stdlib.h> #include<string.h> int main() { // 向内存申清 10 个整形的空间 int *p = (int *)malloc(10 * sizeof(int)); if (p == NULL) { // 打印开辟空间失败的原因 printf("%s\n", strerror(errno)); } else { // 正常使用空间 int i = 0; for (i = 0; i < 10; i++) { *(p + i) = i; } for (i = 0; i < 10; i++) { printf("%d ", *(p+i)); } } // 当动态申请的空间不再使用的时候，就应该还给操作系统 free(p); // p虽然还给了操作系统，但是还是可以访问到相应的地址空间的内容 p = NULL; // 将 p 重新指向空指针，这样 p就没办法操作到对应的地址空间 return 0; }
free函数用来释放动态开辟的内存。
如果参数 ptr 指向的空间不是动态开辟的，那free函数的行为是未定义的。
如果参数 ptr 是NULL指针，则函数什么事都不做。
void* calloc (size_t num, size_t size); // 函数的功能是为 num 个大小为 size 的元素开辟一块空间，并且把空间的每个字节初始化为0。 // 与函数 malloc 的区别只在于 calloc 会在返回地址之前把申请的空间的每个字节初始化为全0。#define _CRT_SECURE_NO_WARNINGS 1 #include<stdio.h> #include<stdlib.h> #include<string.h> int main() { int *p = (int *)calloc(10, sizeof(int)); //开辟 10 个int类型所占的字节的空间，也就是 40个字节 if (p == NULL) { printf("%s\n", strerror(errno)); } else { int i = 0; for (i = 0; i < 10; i++) { printf("%d\n", *(p + i)); } } free(p); p = NULL; return 0; }
2.2.3 realloc
2.2.3.1 realloc增加malloc的空间
realloc函数的出现让动态内存管理更加灵活。有时会我们发现过去申请的空间太小了，有时候我们又会觉得申请的空间过大了，那为了合理的时候内存，我们一定会对内存的大小做灵活的调整。那 realloc 函数就可以做到对动态开辟内存大小的调整。
void* realloc (void* ptr, size_t size); /* ptr 是要调整的内存地址 size 调整之后新大小 返回值为调整之后的内存起始位置。 这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到 新 的空间。 realloc在调整内存空间的是存在两种情况： 情况1：原有空间之后有足够大的空间 情况2：原有空间之后没有足够大的空间 情况1: 当是情况1 的时候，要扩展内存就直接原有内存之后直接追加空间，原来空间的数据不发生变化。 情况2: 当是情况2 的时候，原有空间之后没有足够多的空间时，扩展的方法是：在堆空间上另找一个合适大小的连续空间来使用。这样函数返回的是一个新的内存地址。由于上述的两种情况，realloc函数的使用就要注意一些。 */// realloc 拓展 malloc的空间 #define _CRT_SECURE_NO_WARNINGS 1 #include<stdio.h> #include<stdlib.h> #include<string.h> int main() { // 开辟一个 20 字节的空间 int *p = (int *)malloc(20); int i = 0; for (i = 0; i < 5; i++) { *(p + i) = i; } // 当20个字节的空间已经不够用了，希望增加到 40 字节 int *ptr = realloc(p, 40); if(ptr != NULL) // 追加成功 { p = ptr; } for (i = 0; i < 10; i++) { printf("%d\n", *(p + i)); } return 0; } /* realloc 使用注意事项 1. 如果p指向的空间之后有足够的内存空间可以追加，则直接追加，后返回 p 2. 如果p指向的空间之后没有足够的内存空间可以追加，则realloc函数会重新找一个新的内存区域开辟一块满足需求的空间，并且把原来内存中的数据拷贝回来，释放旧的内存空间，最后返回新开辟的内存空间地址 3. 得用一个新的变量来接收 realloc的返回值，因为开辟新空间可能会失败，这样如果直接返回给指针p的话，p指向的就是的NULL，这样就会修改p所指向的原有数据，所以一般用新的变量来接收新开辟的地址，开辟成功以后再赋值给原本的p指针。 */
int *pt = realloc(NULL, 40);#define _CRT_SECURE_NO_WARNINGS 1 #include<stdio.h> #include<stdlib.h> #include<string.h> { int *pt = realloc(NULL, 40); int i = 0; for (i = 0; i < 10; i++) { *(pt + i) = i; } for (i = 0; i < 10; i++) { printf("%d ", *(pt+i)); } return 0; }
2.3 常见的动态内存错误
2.3.1 对NULL指针的解引用操作
int *p = (int *)malloc(INT_MAX/4); // 在操作指针 p 之前，一般都需要了对p进行判断 *p = 20; //malloc 开辟空间失败 则p的值是NULL，直接解引用就会有问题 free(p);
#define _CRT_SECURE_NO_WARNINGS 1 #include<stdio.h> #include<stdlib.h> #include<string.h> int main() { int *p = (int *)malloc(40); if (p == NULL) { return 0; } int i = 0; for (i = 0; i <= 10; i++) // 越界 { *(p + i) = i; // 越界访问 } free(p); p = NULL; return 0; }
#define _CRT_SECURE_NO_WARNINGS 1 #include<stdio.h> int main() { int a = 10; int *p = &a; free(p); // 直接报错, 只能操作堆区的空间，不能操作栈区空间 return 0; }
#define _CRT_SECURE_NO_WARNINGS 1 #include<stdio.h> #include<stdlib.h> int main() { int *p = (int *)malloc(40); if (p == NULL) { return 0; } int i = 0; for (i = 0; i < 10; i++) { *p++ == i; // *p == i; p++; } free(p); // 直接报错， 因为 p 此时指向的空间已经不是我们初始化开辟的空间了， p不在指向动态内存的起始位置, free(p)只能free初始化的位置，其他位置都不行的 p = NULL; return 0; }
#define _CRT_SECURE_NO_WARNINGS 1 #include<stdio.h> #include<stdlib.h> int main() { int *p = (int *)malloc(40); free(p); free(p); // 直接报错 return 0; }// 不知道自己是不是已经释放过了的话，所以在释放过后一定要指向空指针，然后再继续释放就不会报错了 #define _CRT_SECURE_NO_WARNINGS 1 #include<stdio.h> #include<stdlib.h> int main() { int *p = (int *)malloc(40); free(p); p = NULL; free(p); // 释放空指针是没问题的。 return 0; }
#define _CRT_SECURE_NO_WARNINGS 1 #include<stdio.h> #include<stdlib.h> int main() { while (1) { malloc(10); // 时间一长，内存就被消耗完了 } return 0; }
// 1. 请问运行函数会有什么样的结果 #define _CRT_SECURE_NO_WARNINGS 1 #include<stdio.h> #include<stdlib.h> void GetMemory(char *p) { p = (char *)malloc(100); } void Test(void) { char *str = NULL; GetMemory(str); // str 是值传递过去，所以本身指向的地址并没有改变，还是空指针 strcpy(str, "Hello World"); // 将 "Hello World" 存放到空指针，所以会崩溃 printf("%s\n", str); } int main() { Test(); return 0; } /* 1. 运行程序崩溃了 2. 内存泄漏的问题, str 以值传递的方式给了 p， p是 GetMemory函数的形参，只在函数内部有效，等 GetMemory函数返回之后，动态开辟的内存尚未释放并且无法找到，所以会造成内存泄漏。 *///修改如下, 方式一 void GetMemory(char **p) { *p = (char *)malloc(100); } void Test(void) { char *str = NULL; GetMemory(&str); // 将地址传过去 strcpy(str, "Hello World"); printf("%s\n", str); free(str); str = NULL; }//修改如下, 方式二 char* GetMemory(char *p) { p = (char *)malloc(100); return p; } void Test(void) { char *str = NULL; str = GetMemory(str); strcpy(str, "Hello World"); printf("%s\n", str); free(str); str = NULL; }
// 2. 请问运行函数会有什么样的结果 #define _CRT_SECURE_NO_WARNINGS 1 #include<stdio.h> #include<stdlib.h> char *GetMemory() { char p[] = "Hello World"; return p; } void Test() { char *str = NULL; str = GetMemory(); // 调用函数执行结束的时候，将地址返回给了str，但是函数调用结束之后，指针 p 所指向的空间已经被返回给了操作系统，后面再指向什么就不清楚了，所以最终打印是随机值 printf(str); } int main() { Test(); return 0; }
// 3. 请问运行Test 函数会有什么样的结果？ #define _CRT_SECURE_NO_WARNINGS 1 #include<stdio.h> #include<stdlib.h> void GetMemory(char **p, int num) { *p = (char *)malloc(num); } void Test(void) { char *str = NULL; GetMemory(&str, 100); strcpy(str, "hello"); printf(str); free(str); str = NULL; } int main() { Test(); return 0; } // 没问题， 输出 hello
// 4. 请问运行Test 函数会有什么样的结果？ #define _CRT_SECURE_NO_WARNINGS 1 #include<stdio.h> #include<stdlib.h> void Test(void) { char *str = (char *)malloc(100); strcpy(str, "hello"); free(str); // free 释放完了指针一定要 str = NULL; if (str != NULL) { strcpy(str, "world"); // world printf(str); } } int main() { Test(); return 0; } // 代码能输出 world。 // 但是 已经 free(str); 了，原本 hello所在的地址空间已经与 str进行解绑订了， 但是 str内部还是存储的是 hello原本的地址， 所以 str != NULL; 后面又将 "world" 的地址 赋值给了 str. 所以 str的输出是 world。但是非法访问了内存。
C99 中，结构中的最后一个元素允许是未知大小的数组，这就叫做 柔性数 成员。
/* 结构中的柔性数组成员前面必须至少一个其他成员。 sizeof 返回的这种结构大小不包括柔性数组的内存。 包含柔性数组成员的结构用malloc ()函数进行内存的动态分配，并且分配的内存应该大于结构的大 小，以适应柔性数组的预期大小。 */ // 方式一 struct S1 { int n; int arr[]; }; // 方式二 struct S2 { int n; int arr[0]; }; // 方式三 struct S3 { int n; int *arr; };
// 柔型数组的基本使用 #define _CRT_SECURE_NO_WARNINGS 1 #include<stdio.h> #include<stdlib.h> struct S { int n; int arr[]; // 柔型数组成员，，数组未知大小,数组的大小是可以调整的。 int arr[0]；这样也可以 }; int main() { // printf("%d\n", sizeof(s)); // 4 只计算 int类型的大小，不计算柔型数组的大小 struct S *ps = (struct S *)malloc(sizeof(struct S) + 5 * sizeof(int)); // 5 * sizeof(int) 是让 柔型数组有5个元素 ps->n = 100; int i = 0; for (i = 0; i < 5; i++) { ps->arr[i] = i; } for (i = 0; i < 5; i++) { printf("%d ",ps->arr[i]); // 0 1 2 3 4 } free(ps); ps = NULL; return 0; }
// 柔型数组 + realloc #define _CRT_SECURE_NO_WARNINGS 1 #include<stdio.h> #include<stdlib.h> struct S { int n; int arr[]; // 柔型数组成员，，数组未知大小,数组的大小是可以调整的。 int arr[0]；这样也可以 }; int main() { struct S *ps = (struct S *)malloc(sizeof(struct S) + 5 * sizeof(int)); // 5 * sizeof(int) 是让 柔型数组有5个元素 ps->n = 100; int i = 0; for (i = 0; i < 5; i++) { ps->arr[i] = i; } struct S *ptr = realloc(ps, 44); if (ptr != NULL) { ps = ptr; } for (i = 0; i < 10; i++) { ps->arr[i] = i; } for (i = 5; i < 10; i++) { printf("%d ", ps->arr[i]); } // 释放 free(ps); ps = NULL; return 0; }
// 柔性数组大小可改变 #define _CRT_SECURE_NO_WARNINGS 1 #include<stdio.h> #include<stdlib.h> struct S { int n; int *arr; }; int main() { struct S *ps = (struct S *)malloc(sizeof(struct S)); ps->arr = malloc(5 * sizeof(int)); // 给数组开辟空间 int i = 0; for (i = 0; i < 5; i++) { ps->arr[i] = i; } for (i = 0; i < 5; i++) { printf("%d ",ps->arr[i]); // 0 1 2 3 4 } printf("\n"); // 调整大小 int *ptr = realloc(ps->arr, 10 * sizeof(int)); if (ptr != NULL) { ps->arr = ptr; } for (i = 5; i < 10; i++) { ps->arr[i] = i; } for (i = 0; i < 10; i++) { printf("%d ", ps->arr[i]); // 0 1 2 3 4 5 6 7 8 9 } free(ps->arr); // 释放指针指向的数组的地址 free(ps); // 释放内存 ps = NULL; return 0; }
// 从 2.5.2 几个例子中我们能得出 柔性数组有如下结论:
1.方便内存释放
如果我们的代码是在一个给别人用的函数中，你在里面做了二次内存分配，并把整个结构体返回给用户。用户调用free可以释放结构体，但是用户并不知道这个结构体内的成员也需要free，所以你不能指望用户来发现这个事。所以，如果我们把结构体的内存以及其成员要的内存一次性分配好了，并返回给用户一个结构体指针，用户做一次free就可以把所有的内存也给释放掉。
2. 这样有利于访问速度.
连续的内存有益于提高访问速度，也有益于减少内存碎片。（其实，我个人觉得也没多高了，反正你跑不了要用做偏移量的加法来寻址
