C语言的动态内存分配及动态内存分配函数详解
malloc
malloc的使用：
free
calloc
calloc的使用：
realloc
realloc的使用改进：
realloc的另一种用法：
常见的动态内存错误
对空指针的解引用操作
对动态开辟空间的越界访问
对非动态开辟内存使用free释放
使用free释放一块动态开辟内存的一部分
对同一块动态内存多次释放
动态开辟内存忘记释放（内存泄露）
找出下面问题：
T1：
T2：
T3：
T4：
柔性数组
柔性数组的定义
柔性数组的特点：
总结
mallocvoid *malloc( size_t size );
Tips:这里的size代表的是字节的大小
malloc的使用：//malloc的使用
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>
int main()
{
int* str = 0;
int* p = 0;
str = (int*)malloc(10*sizeof(int));//开辟十个整型空间
if (NULL == str)
{
printf("%s\n", strerror(errno));//若开辟失败
//使用报错函数strerror（errno） 要引用头文件<string.h>
}
else
{
p = str;
}
free(p);
p = NULL;
return 0;
}
free
释放申请的内存空间，例：free(p)
当释放后，虽然p中的值还在，不变，但p就为野指针了。所以建议释放后将p设置为空指针。（p=NULL）
calloccalloc：开辟并且初始化为0的数组。
void* calloc(size_t num,size_t size)
num——元素个数
size——元素大小
成功的话返回地址，失败返回空指针NULL
calloc的使用：#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>
int main()
{
int* str = 0;
int* p = 0;
str = (int*)calloc(10,sizeof(int));
if (NULL == str)
{
printf("%s\n", strerror(errno));
}
else
{
p = str;
}
free(p);
p = NULL;
return 0;
}
realloc
可开辟空间，也可以调整空间。
void *realloc( void *memblock, size_t size );
memblock——要开辟空间的指针类型
size——要开辟的字节大小
p=（int）realloc（p，80）*——这样子写也是有风险的。
风险：为了避免可能会把增容的后面的已有的内存空间给覆盖掉，所以会在另一块大小足够的地方开辟空间，然后把原来的数据转移到新的空间上。并且把原来的内存空间给释放掉。
若realloc调整空间失败，则返回NULL。原来的数据也没有了。
realloc的使用改进：int* ptr=(int*)realloc(p,80);
if(NULL!=ptr)
{
p=ptr;//这样子能够保证确定了不为空指针后才正式传给p，相当于没有了会失去原来数据的风险
}
realloc的另一种用法：
int* p=（int*）realloc（NULL，40）；
这种写法相当于malloc
常见的动态内存错误 对空指针的解引用操作将malloc函数开辟一个贼大的空间，INT_MAX，此时会有一个空指针，进行判断，如果为空指针就立马结束这个程序了。不要出问题（ps:这里的INT_MAX的使用要引用头文件limits.h）
所以要判断是不是空指针，是的话就中断，例：
//错误写法
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <limits.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>
int main()
{
int i = 0;
int* p = (int*)malloc(INT_MAX);
for (i = 0; i < 5; i++)
{
*(p + i) = i;
}
return 0;
}
//正确写法：
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <limits.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>
int main()
{
int i = 0;
int* p = (int*)malloc(INT_MAX);
if (p == NULL)
{
printf("%s\n", strerror(errno));//这里是将错误报出来
return 0;//发现是空指针，提前结束
}
for (i = 0; i < 5; i++)
{
*(p + i) = i;
}
return 0;
}
对动态开辟空间的越界访问
不可以不申请即使用动态内存空间，会报错的。
Tips：没有开辟的空间是不能使用的
对非动态开辟内存使用free释放int main()
{
int p=0;
int* a=&p;
free(a);//这个样子是错误的
return 0;
}
使用free释放一块动态开辟内存的一部分
开辟动态空间的时候，一定要把起始位置给用变量存好，否则到时会无法释放内存。
//使用free释放一块动态开辟内存的一部分
//正确写法：
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>
int main()
{
int i = 0;
int* p = (int*)malloc(10 * sizeof(int));
//正确写法：
for (i = 0; i < 5; i++)
{
*(p + i) = i;
}
free(p);
p=NULL;
return 0;
}
//错误写法：
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>
int main()
{
int i = 0;
int* p = (int*)malloc(10 * sizeof(int));
//错误写法：
for (i = 0; i < 5; i++)
{
*p = i;
p++;//这里会改变p的原始位置，使得无法指向一开始开辟动态内存空间的位置，最终报错
}
free(p);
p = NULL;
return 0;
}
对同一块动态内存多次释放
一块空间释放后不可再释放，但释放完后p置为空指针再次释放时不会报错。
Q：free空指针时会有问题么？
A：不会，因为一块空间释放后就不能再次释放了，所以每次free完后记得置为空指针。
动态开辟内存忘记释放（内存泄露）即使在函数中开辟内存空间也要记得释放。因为出了函数在外面想释放也无法释放。
但如果返回首元素的地址，free了也行，就是无论怎么样，一定要释放。
在任何地方开辟的内存空间都最好要释放。
找出下面问题： T1：void GetMemory(char* p)
{
p=(char*)malloc(100);
}
void Test(void)
{
char* str=NULL;
GetMemory(str);
strcpy(str,"hello world");
printf(str);
}
int main()
{
Test();
return 0;
}
出现的问题：
在这里str是空指针，而p只是新建的一个形参，运行完函数后无法返回p不存在了，但是内存空间还未被释放，而这个空间的地址此时是没有人能够知道的。也并不能将str里面的NULL改变，所以在strcpy时会出错，因为str此时为NULL指针，会造成非法访问内存，程序会崩溃。
而且在使用过程中只进行了动态内存的开辟，没有进行动态内存的释放，可能会造成动态内存泄露。
改进方法：
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
char* GetMemory(char* p)
{
p = (char*)malloc(100);
return p;
}
void Test(void)
{
char* str = NULL;
str = GetMemory(str);
strcpy(str, "hello world");
printf(str);
free(str);
str = NULL;
}
int main()
{
Test();
return 0;
}
函数的栈帧与创建：p尽管销毁，因为会先把p里面的值放入到寄存器中，寄存器里面不会销毁，之后再从寄存器位置传进去str。
出现的问题：
返回栈空间地址问题：
这里虽然能把p的地址传回去，但是在函数运行完后在函数里面创建的数据会被销毁，也就是说虽然能通过指针找到原来的内存所指向的地方，但是数据都以被销毁。
注意！！！
这样是可以的，因为返回的是栈空间的变量而不是栈空间的地址。
总结：
在创造函数如果返回地址而不是返回值，在用的时候可能依然是在函数内的值，但也有很大可能不是，可能不是的原因是有关函数栈帧方面，如果在引用地址前再写上一段例如："printf("23333\n");"，可能会导致覆盖掉原来地址上的数据，所以无法通过传址来输出真正的值，因为会被覆盖掉。
T3：
出现的问题：
除了free没有太大毛病了。这里能够打印出hello。
T4：
出现的问题：
这里的free其实是把动态内存空间还给系统了，但是str的话没有定为空指针，仍然存着当初指向开辟的内存空间的地址，那么就还可以通过str找到当初开辟的内存空间，只是这个时候因为释放（free）str了，所以此时没有访问空间的权限，也就无法将world拷贝到str所指向的空间。
正确改法：
所以，在每次free后面都要记得设置为空指针。
柔性数组在c99中，结构体中的最后一个元素是允许未知大小的数组，这就叫做【柔性数组】成员。
柔性数组的定义//写法一：
struct s1
{
int n;
int arr[0];//大小是未指定
}
//写法二：
struct s2
{
int n;
int arr[];//大小是未指定
}
//总会有一种写法编译器不报错
Tips:在计算包含柔性数组大小的时候，柔性数组是不计算在大小里面的。（可以写一个来试一下）
柔性数组的特点：柔性数组前至少需要一个其他成员
sizeof返回的这种结构大小不包括柔性数组的内存
包含柔性数组成员的结构用malloc（）函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小。
柔性数组的开辟（自己先写）
包含柔性数组的结构体不可以直接创建，而是要有malloc来开辟空间。
//写柔性数组的方法一：
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
struct p
{
int i;
int arr[];
};
int main()
{
struct p* cmp = (struct p*)malloc(sizeof(struct p) + 80);//这里是开辟了一共84个字节空间，分给arr数组80个字节空间
free(p);
p = NULL;
return 0;
}
//写柔性数组的方法二：（先开辟整个的，再开辟数组的）
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
struct p
{
int i;
int* arr;//这样才能在方法二中使用
};
int main()
{
struct p* cmp = (struct p*)malloc(sizeof(struct p));
cmp->i = 10;
cmp->arr = (int*)malloc(80);//从数组开始，再次开辟80个字节空间
free(p);
p = NULL;
return 0;
}
第二种方案（劣势）：
1.开辟和释放的次数多，容易出错
2.频繁多次开辟内存，会有内存碎片出现，可能会导致内存的使用效率不高
第一种方案优势：
1.方便释放
2.减少内存碎片的出现
总结本篇文章就到这里了，希望能够给你带来帮助，也希望您能够多多关注软件开发网的更多内容!
