动态内存函数
在堆区申请的空间，动态开辟的空间不要忘了释放
malloc
参数是无符号的整型，
malloc
参数是无符号的整型，
例：
#include <stdio.h> #include <stdlib.h> #include <string.h> int main() { char* p = (char*)malloc(10 * sizeof(char)); if (p == NULL) { printf("%s", strerror(errno)); return 0; } char* arr = p; int i = 0; for (i = 0; i < 10; i++) { *arr++ = i; } free(p); p = NULL; return 0; }
calloc
开辟动态内存空间的同时初始化空间为0，每个字节都初始化为0。
num是元素的个数，size每个元素的大小。开辟空间成功返回指向该空间的指针
开辟空间失败返回空指针
NULL。
例：
#include <stdio.h> #include <stdlib.h> #include <string.h> int main() { int* p = (int*)calloc(5, sizeof(int));; if (p == NULL) { printf("%s\n", strerror(errno)); return 0; } int i = 0; for (i = 0; i < 5; i++) { *(p + i) = i; } free(p); p = NULL; return 0; }
realloc
重新分配动态内存的函数.。
第一个参数为指向动态开辟空间的指针，第二个参数为从新开辟内存的大小，单位字节。
当第一个参数为空指针
NULL时。和malloc一样。开辟成功返回，返回从新开辟空间的地址。
开辟失败返回空指针。
有两种情况：
1. 以前动态开辟的空间后面的空间够再次开辟，那么
realloc直接在以前开辟的后面进行开辟。
2. 以前动态开辟的空间后面的空间不够再次开辟，会重新找一块空间进行开辟，同时把以前的数据拷贝新开辟的里面。以前动态开辟的空间被销毁。
例：
#include <stdio.h> #include <stdlib.h> #include <string.h> int main() { char* p = (char*)malloc(10 * sizeof(char)); if (p == NULL) { printf("%s\n", strerror(errno)); return 0; } char* str = (char*)realloc(p, 20 * sizeof(char)); if (str == NULL) { printf("%s\n", strerror(errno)); return 0; } p = str; free(p); p = NULL; return 0; }
free
释放动态开辟的内存空间。参数是指向动态内存的指针，是首地址。
当参数为
NULL的时候，什么都不发生。
常见的动态内存错误
对NULL指针的解引用操作
这里的
p万一是空指针，下面这种就是错误
char* p = (char*)malloc(10 * sizeof(char)); *p = 1;
正确的做法是开辟完成之后，需要判断是不是空指针。
对动态开辟空间的越界访问
其实和数组一样，动态内存开辟的空间也有边界，也是不能越界的。
char* p = (char*)malloc(10 * sizeof(char)); if (p == NULL) { printf("%s\n", strerror(errno)); return 0; } int i = 0; for (i = 0; i <= 10; i++)//当i=10的时候就越界了 { *(p + i) = i; }
释放非动态内存开辟的空间
int a = 10; int* p = &a; free(p); p = NULL;
使用free释放一块动态开辟内存的一部分
free一定要释放指向动态内存开辟的那个首地址。
char* p = (char*)malloc(10 * sizeof(char)); if (p == NULL) { printf("%s\n", strerror(errno)); return 0; } int i = 0; for (i = 0; i <5; i++) { *p++ = i; } //这里释放一部分，这是错误的。 free(p);
对同一块动态内存多次释放
char* p = (char*)malloc(10 * sizeof(char)); if (p == NULL) { printf("%s\n", strerror(errno)); return 0; } free(p); free(p);
解决方法为：释放空间之后就制成空指针。
动态开辟内存忘记释放（内存泄漏）
一定一定不要忘了释放
char* f() { char* p = (char*)malloc(10); return p; } int main() { char* ret = f(); return 0; }
柔性数组
结构体中允许最后一个成员为未知大小的数组，该数组就是柔性数组成员。
例：
struct s { int i; int arr[]; 下面的这种也是可以的 int arr[0]; };
柔性数组的特点
1.结构体至少包括一个非柔性数组成员
2.
sizeof求这种类型的时候，不包括柔性数组。3.动态开辟的时候，其开辟的大小要大于这种类型的大小。以满足可以给柔性数组进行开辟空间。
使用：
struct sstruct s { int i; int arr[]; //int arr[0]; }; int main() { struct s* p = (struct s*)malloc(sizeof(struct s) + 20); if (p == NULL) { return 0; } p->i = 6; int n; for (n = 0; n < 5; n++) { p->arr[n] = n; } free(p); p = NULL; return 0; }
像上面那样，我们还可以用其他的方式进行实现：
如
struct s { int i; int* arr; }; int main() { struct s* p = (struct s*)malloc(sizeof(struct s)); if (p == NULL) { return 0; } p->i = 6; p->arr = (int*)malloc(5 * sizeof(int)); free(p->arr); p->arr = NULL; free(p); p = NULL; return 0; }
虽然这样也可以实现，但是两次开辟的空间不是连续。要注意释放的顺序，否则会造成内存泄漏。
使用柔性数组不会出现这种情况。
