动态内存管理
前言
为什么会引出动态内存开辟这个功能呢？
那是因为向我们之前学习的数组，一旦创建之后所占用的空间就不会改变，可能会造成空间的浪费或者开辟空间的不足。
一，malloc
void* malloc(size_t num)
1，函数的返回类型为空指针类型，如果为开辟成功那么返回NULL
2，函数的参数为开辟空间的大小（单位：字节）
3，函数开辟的空间十载内存中的堆区开辟的，会在整个程序结束后自动销毁
4，演示
#include<stdio.h>
#include<stdlib.h>
int main()
{
int* p = (int*)malloc(sizeof(int) * 5);
if (p == NULL)
{
perror("malloc");
}
else
{
int i = 0;
for (i = 0; i < 5; i++)
{
*(p + i) = i;
}
for (i = 0; i < 5; i++)
{
printf("%d ", *(p + i));
}
}
free(p);
p = NULL;
return 0;
}
注意 ：开辟不成功返回NULL
#include<stdio.h>
#include<stdlib.h>
#include<limits.h>
int main()
{
int* p = (int*)malloc(INT_MAX*sizeof(int));
if (p == NULL)
{
perror("malloc");
}
else
{
int i = 0;
for (i = 0; i < 5; i++)
{
*(p + i) = i;
}
for (i = 0; i < 5; i++)
{
printf("%d ", *(p + i));
}
}
free(p);
p = NULL;
return 0;
}
二，free
void free(void* ptr)
1，函数的返回值为空，函数的参数为空指针
2，作用是将ptr指向的动态开辟的空间释放
3，可以free（NULL）
4，我们在动态开辟内存空间后，并且使用完后，要及时free释放空间，避免造成内存泄漏。
5，free掉空间后，最好将原指针指向NULL，避免造成非法访问
三，calloc
void* calloc(size_t num,size_t n)
1，函数的返回值为空指针类型
2，第一个参数表示开辟元素的个数，第二个参数表示每个元素的大小（单位：字节）
3，calloc与malloc大体相同，区别为calloc申请的空间会被初始化为0.
四，realloc
void* realloc (void* ptr, size_t size)
1，函数的返回值为空指针类型
2，第一个参数为空指针类型是一块动态开辟空间的地址，第二个参数是重新调整后动态开辟空间的大小
3，realloc（NULL，40）==malloc（NULL，40）
4，这个函数可以对之前开辟的空间重新调整可大可小
5，在用realloc函数扩容的时候，若原空间后面的空间充足，那么新开辟的空间就是与原空间挨着的后面的空间
6，在用realloc函数扩容的时候，若原空间后面的空间不充足，那么会找到一块新的空间大小为扩容后的大小，并且会将原空间的内容拷贝到新空间中，还会释放掉原空间。
可以看到当扩容的空间较小时，会直接在原空间的基础上开辟新的空间。
可以看到当扩容的空间较大时，系统会重新找到一块空间。
五，动态内存管理的常见问题
1，对空指针进行解引用操作
void test2()
{
int* p = (int*)malloc(sizeof(int) * INT_MAX);
*p = 20;
free(p);
}
这里如果p为空指针的话，那么就会对空指针解引用。
如何改进呢？
void test2()
{
int* p = (int*)malloc(sizeof(int) * INT_MAX);
if (p == NULL)
{
perror("malloc");
}
else
{
*p = 20;
}
free(p);
p = NULL;
}
2，对动态开辟的空间越界访问
void test3()
{
int* p = (int*)malloc(sizeof(int) * 5);
if (p != NULL)
{
int i = 0;
for (i = 0; i < 10; i++)
{
*(p + i) = i;
}
}
free(p);
p = NULL;
}
这里看到我们用malloc开辟了20个字节的内容，而我们在赋值的时候却访问了40个字节的内容，这就造成了，对动态开辟内存空间的越界访问。
3，对非动态开辟的内存空间free
void test4()
{
int a = 10;
free(&a);
}
4，使用free释放动态内存开辟的一部分
void test5()
{
int* p = (int*)malloc(sizeof(int) * 5);
if (p != NULL)
{
int i = 0;
for (i = 0; i < 5; i++)
{
*p = i;
p++;
}
}
free(p);
p = NULL;
}
我们在赋值的时候已经将p指向的空间移动，这样之后就不能再用free（p）来释放动态开辟的空间
5，对一块动态开辟的空间多次释放
void test6()
{
int* p = (int*)malloc(sizeof(int) * 5);
free(p);
//...
//...
//...
//...
free(p);
}
6，动态开辟的内存空间忘记释放（内存泄漏）
这就是内存开辟之后，使用完忘记释放空间。
void test5()
{
int* p = (int*)malloc(sizeof(int) * 5);
if (p != NULL)
{
int i = 0;
for (i = 0; i < 5; i++)
{
*(p + i) = i;
}
}
}
注 ：以上就是动态内存开辟过程中容易出错的六个地方，在你写代码的时候要注意哟。
六，四道经典面试题目
每道题目哪里出了问题？
第一道
void GetMemory(char *p)
{
p = (char *)malloc(100);
}
void Test(void)
{
char *str = NULL;
GetMemory(str);
strcpy(str, "hello world");
printf(str);
}
1，对p开辟的空间，并不会带回函数test中，所以str一直指向的都是NULL，在调用strcpy时，会造成对空指针解引用。
2，对动态开辟的空间没有free
纠正
void GetMemory(char** p)
{
*p = (char*)malloc(100);
}
void Test(void)
{
char* str = NULL;
GetMemory(&str);
if (str != NULL)
{
strcpy(str, "hello world");
printf(str);
}
free(str);
str = NULL;
}
第二道
char *GetMemory(void)
{
char p[] = "hello world";
return p;
}
void Test(void)
{
char *str = NULL;
str = GetMemory();
printf(str);
}
这是一种常见的错误就是，返回栈空间地址，函数返回了p指针p但是指针p指向的内容已被销毁。
第三道
void GetMemory(char **p, int num)
{
*p = (char *)malloc(num);
}
void Test(void)
{
char *str = NULL;
GetMemory(&str, 100);
strcpy(str, "hello");
printf(str);
}
1，主要问题是没有释放动态开辟的内存空间造成内存泄漏。
2，还有一个小问题就是在使用str时没有提前判断str是否为空指针
纠正
void GetMemory2(char** p, int num)
{
*p = (char*)malloc(num);
}
void Test2(void)
{
char* str = NULL;
GetMemory(&str, 100);
if (str != NULL)
{
strcpy(str, "hello");
printf(str);
}
free(str);
str = NULL;
}
第四道
void Test(void)
{
char *str = (char *) malloc(100);
strcpy(str, "hello");
free(str);
if(str != NULL)
{
strcpy(str, "world");
printf(str);
}
}
1，这道题的问题所在是，释放掉str所指向的空间后，没有将str指向空指针。这造成了调用strcpy函数时形成了非法访问。
纠正
void Test3(void)
{
char* str = (char*)malloc(100);
strcpy(str, "hello");
free(str);
str = NULL;
if (str != NULL)
{
strcpy(str, "world");
printf(str);
}
}
以上四道题目都出自《高质量的C/C++编程》这本书中。
链接：https://pan.baidu.com/s/19mSw3miWFz7GYaMfaZ3uIw
提取码：kbtz