一.为什么存在动态内存开辟

开辟空间的特点：

1. 空间开辟大小是固定的

2. 数组在申明时，必须指定数组长度，她所需要的内存在编译时分配

但是对于空间的需求，不仅仅是上述的情况。有时候我们需要的空间大小在程序运行的时候才能知道，

那数组的编译时开辟空间的方式就不能满足了。

这时候就只能试试动态存开辟了

二.动态内存函数的介绍

1.malloc和free

void*malloc(size_t size);

这个函数向内存申请一块连续的内存空间，并返回这块空间的指针。

• 如果开辟成功，则返回一个指向这块空间的指针

• 如果开辟失败，这返回一个NULL，因此malloc函数的返回值一定要做检查

• 返回的类型是void*，所以malloc函数并不知到开辟空间的类型，具体在使用时使用者自己决定

• 如果参数 size 为0，malloc的行为是标准是未定义的，取决于编译器

free函数使用来释放动态开辟的内存的

void free(void*ptr)

• 如果参数ptr指向的空间不是动态内存开辟的，那么free函数的行为是未定义的

• 如果ptr是NULL，则free函数什么都不做

注：malloc和free都声明在stdlib.h的文件中

例：

#include<stdio.h>int main()
{int num=0；scanf("%d",&num)；int arr[num]=0;//变长数组int*ptr=NULL；ptr=(int*)malloc(num*sizeof(int))；if(NULL!=ptr)//判读ptr是否为空指针{int i=0；for(i=0;i<num;i++){*(ptr+i)=i；}}free(ptr)；//释放ptr所指向的动态内存ptr=NULL；//是否有必要？return 0；
}

虽然程序结束后被开辟的内存空间会被释放，但是这样浪费的很多空间，而free能够充分利用内存空间。

最后虽然free(ptr)释放了开辟的动态空间，但是ptr仍然指向那个空间的地址，所以要将ptr设置为空指针来避免空间被不会好意的人通过ptr找到。

2.calloc

void*callor(size_t num,size_t size)

• 函数的功能是为 num 个大小为 size 的元素开辟一块空间，并且把空间的每个字节初始化为0

• 与函数 malloc 的区别只在于 calloc 会在返回地址之前把申请的空间的每个字节初始化为全0。

例：

#include<stdio.h>
#include<stdlib.h>
int main()
{int* p = calloc(10, sizeof(int));if(NULL != p){//使用空间}free(p);p = NULL;return 0;
}

3.realloc

• realloc函数的出现让动态内存管理更加灵活

• realloc 函数就可以做到对动态开辟内存大小

的调整。

void*realloc(void*str,size_t size);

• ptr是要调整的内存地址

• size是调整之后的内存大小

• 返回调整之后内存的起始位置

• 这个函数在调整原内存空间的大小的基础上，还会将原内存的数据移到新的空间里

• realloc在调整内存空间时有两种情况

情况1：原有空间之后有足够大的空间

情况2：原有空间之后没有足够大的空间

当是情况1的时候，要扩展的内存就在原有的内存之后追加新的空间，原来的数据不发生改变。

当是情况2的时候，扩展的方式就是在堆空间上另找一个适合大小的连续空间使用。这样函数返回的是一个新的内存地址。

例：

int main()
{int* ptr = (int*)malloc(100);if (NULL == ptr){perror(ptr);}else{int i = 0;for(i=0;i<100;i++){*(ptr + i) = i;}}//扩展容量ptr = (int*)realioc(ptr, 1000);//这样可以吗？(如果申请失败会如何？)if (NULL == ptr){perror(ptr);}else{int i = 0;for(i=100;i<=1000;i++){*(ptr + i) = i;}free(ptr);ptr = NULL;return 0;
}

不能像代码1一样操作，因为若(int*)realloc(ptr, 1000)中realloc开辟失败，返回的空指针赋给了ptr，

那么ptr被改掉，ptr指向的空间就找不到了

修改后：

int main()
{int* ptr = (int*)malloc(100);if (NULL == ptr){perror(ptr);}else{int i = 0;for (i = 0; i < 100; i++){*(ptr + i) = i;}}//扩展容量int* p = NULL;p=realloc(ptr, 1000);if (p == NULL){perror(p);}else{ptr = p;int i = 0;for (i = 100; i <= 1000; i++){*(ptr + i) = i;}}free(ptr);ptr = NULL;return 0;
}

三.常见的动态内存错误

1.对空指针的解引用操作

void test()
{int* p = (int*)malloc(INT_MAX);*p = 20;//如果p是空指针就会有问题free(p);
}

2.对动态开辟空间的越界访问

void test()
{int i = 0;int* p = (int*)malloc(10 * sizeof(int));if (NULL == p){exit(EXIT_FAILURE);}for (i = 0; i <= 10; i++){*(p + i) = i;//当i是10的时候越界访问}free(p);
}

3.对非动态开辟内存使用free释放

void test()
{int a = 10;int* p = &a;free(p);
}

4.使用free释放动态开辟内存的一部分

void test()
{int* p = (int*)malloc(10 * sizeof(int));p++;free(p);//p不再指向动态内存的起始位置
}

5.对同一块内存多次释放

void test()
{int *p = (int *)malloc(100);free(p);free(p);//重复释放
}

6.动态内存开辟忘记释放（内存泄漏）

void test()
{int *p = (int *)malloc(100);if(NULL != p){*p = 20;}
}
int main()
{test();while(1);
}

注：忘记释放不再使用的动态开辟的空间会造成内存泄漏

四.几个经典的笔试题

题目1.

void GetMemory(char *p)
{p = (char *)malloc(100);
}
void Test(void)
{char *str = NULL;GetMemory(str);strcpy(str, "hello world");printf(str);
}

请问运行Test 函数会有什么样的结果？

结果：

1. 运行代码会出现兵溃的现象

2. 程序存在内存泄漏

原因是str以值传递的形式给p

p是GetMemory函数的形参，只能在函数内部有效

等GetMemory函数返回返回之后，动态开辟内存尚未释放

并且无法找到，所以会造成内存泄漏

改进：

法一：

可以传str的指针给GetMemory函数,*p就是str

在使用完str后释放它指向的内存空间并将str置为NULL

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;
}int main()
{test();return 0;
}

法二：

将GetMemory的返回类型改为char*，返回指向开辟空间的地址

在使用完str后释放它指向的内存空间并将str置为NULL

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;
}

题目2.

char *GetMemory(void)
{char p[] = "hello world";return p;
}
void Test(void)
{char *str = NULL;str = GetMemory();printf(str);
}int main()
{test();return 0;
}

请问运行Test 函数会有什么样的结果？

结果：打印的是随机值