1. 为什么要有动态内存管理？
例1：
//固定的向内存申请4个字节
int a = 10;
//申请连续的一块空间
int arr[10];这些数据一旦声明定义之后就会在内存中有一块空间，这些空间都是固定的，为了让内存使用更加灵活，这时我们引入了动态内存分配
2. 动态内存分配的函数
使用这些函数之前，我们需要包含头文件stdlib，内存的申请都是在堆区上进行的
->1. malloc 函数
malloc向系统申请内存空间，申请到的空间没有初始化，直接返回的起始地址
开辟成功，则返回一个开辟好空间的指针
开辟失败，则返回一个NULL
若参数为0，nalloc的行为是标准未定义的，取决于编译器
void* malloc(size_t size);(1). 需要开辟空间的总大小
例1：
#include <stdio.h>
#include <stdlib.h>
int main()
{
int*p = (int*)malloc(40);
if(p == NUll)
{
perror("malloc");
return 1;
}
int i = 0;
for(i = 0; i < 10; i++)
{
*(p + i) = 0;
}
for(i = 0; i < 10; i++)
{
printf("%d", p + i);
}
free(p);
p = NULL;
}
可以看到p向系统申请了10个字节的空间，在我们的操作下都赋值为了0
我们来看看将p释放之后：
将p释放了之后p还是指向的原地址，即：释放之后p变成了野指针
所以当我们释放了p之后，再将它手动置0是最安全的
->2. free函数
只能释放malloc ，calloc，realloc向内存申请的空间
如果free函数的参数为NULL，那么free函数不会进行任何操作
void free( void *memblock );(1). void *memblock 需要释放的空间地址
例1：
以malloc为例：
#include <stdio.h>
#include <stdlib.h>
int main()
{
int*p = (int*)malloc(40);
if(p == NUll)
{
perror("malloc");
return 1;
}
int i = 0;
for(i = 0; i < 10; i++)
{
*(p + i) = 0;
}
for(i = 0; i < 10; i++)
{
printf("%d", p + i);
}
free(p);
p = NULL;
}->3.calloc函数
在堆上申请空间（申请好空间后，会把空间初始化为0，然后返回起始地址）
void *calloc( size_t num, size_t size );(1). size_t num 需要开辟空间的个数
(2). size_t size 每个的大小
例1：
#include <stdio.h>
#include <stdlib.h>
int main()
{
int *p = (int*)calloc(10, sizeof(int));
if(p == NUll)
{
perror("calloc");
return 1;
}
int i = 0;
for(; i < 10; i++)
{
printf("%d", *(p + i));
}
free(p);
p = NULL;
return 0;
}->4. realloc函数
有时我们会发现过去我们申请的内存小了，有时发现我们申请的内存大了为了应对这种情况，C语言引入了realloc函数来调整内存。
void *realloc( void *memblock, size_t size );(1). void *memblock 要调整空间的地址
(2).size_t size 需要调整的空间的大小
例1：
#include <stdio.h>
#include <stdlib.h>
int main()
{
int* p = (int*)malloc(sizeof(int) * 5);
if(p == NULL)
{
perror("malloc");
return 1;
}
int i = 0;
for(; i < 5; i++)
{
*(p + i) = 1;
}
for(i = 0; i < 5; i++)
{
printf("%d ", *(p + i));
}
printf("\n");
int* ptr = (int*)realloc(p, sizeof(int) * 10);
if(ptr == NULL)
{
perror("realloc");
return 1;
}
p = ptr;
for(; i < 10; i++)
{
*(p + i) = 1;
}
for(i = 0; i < 10; i++)
{
printf("%d ", *(p + i));
}
free(p);
p = NULL;
return 0;
}realloc的工作原理：
如例1所述：
->1. 后边有足够大的空间可以扩容时，realloc会直接在原有的基础上向后续上新的空间，返回旧的初始地址
->2. 后边没有足够大的空间可以扩容时，realloc函数会找一个满足空间大小的新的连续的空间，把旧的空间的数据拷贝到新空间的前面的位置，并且把旧的空间释放掉，同时返回新的空间的地址
->3. 如果realloc函数的参数是NULL，那么realloc函数的作用和malloc是一样的
例2：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main()
{
int* p = (int*)realloc(NULL, 40);
if(p == NULL)
{
printf("%s", strerror(errno));
return 1;
}
int i = 0;
for(; i < 10; i++)
{
*(p + i) = 1;
}
for(i = 0; i < 10; i++)
{
printf("%d ", *(p + i));
}
free(p);
p = NULL;
return 0;
}运行结果：
由图可知当realloc的参数是NULL时，它的作用和malloc是一样的
3. 常见的动态内存错误
->1. 对NULL解引用操作
malloc的返回值一定要判断
例1：
#include <stdio.h>
#include <stdlib.h>
int main()
{
int* p = (int*)malloc(40);
if(p == NULL)
{
perror("malloc");
return 1;
}
//判断之后在使用
return 0;
}->2.对动态开辟内存的越界访问
越界访问，程序终端就挂了，卡死了
例1：
#include <stdio.h>
int main()
{
int* p = (int*)malloc(100);
if(p == NULL)
{
perror("malloc");
return 1;
}
int i = 0;
for(i = 0; i < 100; i++)
{
*(p + i) = 0;
}
free(p);
p = NULL;
return 0;
}运行结果：
->3. 对非动态开辟内存使用free释放
使用free释放一块动态开辟内存的一部分
例1：
#include <stdio.h>
#include <stdlib.h>
int main()
{
int* p = (int*)malloc(100);
if(p == NULL)
{
perror("malloc");
return 1;
}
int i = 0;
for(i = 0; i < 25; i++)
{
*p = i;
p++;
}
free(p);
p = NULL;
return 0;
}运行结果：
成因：
p指向的已经不再是这一百个字节的起始位置了或者指向这个空间的一部分，不是起始位置
->5. 对同一块动态内存多次释放
例1：
#include <stdio.h>
#include <stdlib.h>
int main()
{
int* p = (int*)malloc(100);
if(p == NULL)
{
perror("malloc");
return 1;
}
free(p);
free(p);
return 0;
}运行结果：
程序直接挂掉
->6. 动态内存忘记释放（内存泄漏）
如果在函数中没有及时的释放动态内存，等函数销毁之后就没有机会了，只能等程序结束
例1：
#include <stdio.h>
#include <stdlib.h>
void test()
{
int* p = (int*)malloc(100);
if(P == NULL)
{
perror("malloc");
return 1;
}
int i;
for(i = 0; i < 25; i++)
{
*(p + i) = 1;
}
for(i = 0; i < 25; i++)
{
printf("%d ", *(p + i));
}
}
int main()
{
test();
return 0;
}解决方法：动态内存开辟函数应该和free函数成对使用
例2：
在函数中申请的内存没有使用完，将malloc开辟的空间的起始地址返回到main函数中继续使用，在使用完之后记得释放
#include <stdio.h>
#include <stdlib.h>
int* test()
{
int* p = (int*)malloc(100);
if(p == NULL)
{
perror("malloc");
return 1;
}
return p;
}
int main()
{
int* ptr = test();
free(ptr);
ptr = NULL;
return 0;
}4.为什么需要用free释放申请的内存
虽然我们不使用free释放空间到程序结束也会呗系统释放掉，但是我们如果碰到一直运行的程序呢！
while(1)
{
malloc(1);
}
他会一直吃掉系统的内存，导致系统的内存越来越少
用free释放空间也需要找准时机
#include <stdio.h>
#include <stdlib.h>
int main()
{
int* p = (int*)malloc(100);
if(p == NULL)
{
perror("malloc");
return 1
}
if(1)
return 1;
free(p);
p = NULL;
return 0;
}这样的就是释放时机没把握好，该代码应该在if语句上面释放
5.例题
例1：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void GetMemory(char* p)
{
p = (char*)malloc(100);
}
void test(void)
{
char* str = NULL;
GetMemory(str);
strcpy(str, "Hello World");
printf(str);
return 0;
}
int main()
{
test();
return 0;
}
运行结果：
错误原因：
1.str传给p值的时候，p是str的一份临时拷贝，有自己独立的空间GetMemory在向系统申请空间之之后，放入了p中，在GetMemory返回之后，str的值依旧是NULL，即在strcpy拷贝时，形参非法范问了空间
2.在GetMemory函数申请空间之后，内存没有能及时的释放，造成了空间泄漏
将例1修改正确：
->1.第一种改法
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void GetMemory(char** p)
{
*p = (char*)malloc(100);
}
void test(void)
{
char* str = NULL;
GetMemory(&str);
strcpy(str, "Hello World");
printf(str);
free(str);
str = NULL;
return 0;
}
int main()
{
test();
return 0;
}运行结果：
->2.第二种改法
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
char* GetMemory()
{
char* p = (char*)malloc(100);
return p;
}
void test(void)
{
char* str = NULL;
str = GetMemory();
strcpy(str, "Hello World");
printf(str);
free(str);
str = NULL;
return 0;
}
int main()
{
test();
return 0;
}运行结果：
