c语言内存开辟
动态内存函数
在堆区申请的空间，动态开辟的空间不要忘了释放
malloc
参数是无符号的整型，表示的是多少字节数。当参数为0时，这是标准没有定义的。取决于编译器。 返回类型为
void*的指针。 当空间开辟成功的时候，返回指向该空间的地址。 当空间开辟失败的时候，返回空指针。malloc开辟是一个连续的空间。开辟完成之后都要判断一下有没有成功
例：
c#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。
例：
c#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. 以前动态开辟的空间后面的空间不够再次开辟，会重新找一块空间进行开辟，同时把以前的数据拷贝新开辟的里面。以前动态开辟的空间被销毁。
例：
c#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万一是空指针，下面这种就是错误
c char* p = (char*)malloc(10 * sizeof(char));
*p = 1;正确的做法是开辟完成之后，需要判断是不是空指针。
对动态开辟空间的越界访问
其实和数组一样，动态内存开辟的空间也有边界，也是不能越界的。
c 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;
}释放非动态内存开辟的空间
cint a = 10;
int* p = &a;
free(p);
p = NULL;使用free释放一块动态开辟内存的一部分
free一定要释放指向动态内存开辟的那个首地址。
c 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);对同一块动态内存多次释放
c char* p = (char*)malloc(10 * sizeof(char));
if (p == NULL)
{
printf("%s\n", strerror(errno));
return 0;
}
free(p);
free(p);解决方法为：释放空间之后就制成空指针。
动态开辟内存忘记释放（内存泄漏）
一定一定不要忘了释放
cchar* f()
{
char* p = (char*)malloc(10);
return p;
}
int main()
{
char* ret = f();
return 0;
}柔性数组
结构体中允许最后一个成员为未知大小的数组，该数组就是柔性数组成员。
例：
cstruct s
{
int i;
int arr[];
下面的这种也是可以的
int arr[0];
};柔性数组的特点
1.结构体至少包括一个非柔性数组成员 2.
sizeof求这种类型的时候，不包括柔性数组。 3.动态开辟的时候，其开辟的大小要大于这种类型的大小。以满足可以给柔性数组进行开辟空间。
使用：
cstruct 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;
}像上面那样，我们还可以用其他的方式进行实现： 如
cstruct 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;
}虽然这样也可以实现，但是两次开辟的空间不是连续。要注意释放的顺序，否则会造成内存泄漏。 使用柔性数组不会出现这种情况。