C语言动态内存管理-优快云博客

一、动态分配内存的概述

在数组一章中，介绍过数组的长度是预先定义好的，在整个程序中固定不变，但是在实际的编程中，往往会发生这种情况，即所需的内存空间取决于实际输入的数据，而无法预先确定。为了解决上述问题，Ｃ语言提供了一些内存管理函数，这些内存管理函数可以按需要动态的分配内存空间，也可把不再使用的空间回收再次利用。动态分配内存就是在堆区开辟空间。

二、静态分配、动态分配

静态分配
1、在程序编译或运行过程中，按事先规定大小分配内存空间的分配方式。int a [10]
2、必须事先知道所需空间的大小。
3、分配在栈区或全局变量区，一般以数组的形式。
4、按计划分配。
动态分配
1、在程序运行过程中，根据需要大小自由分配所需空间。
2、按需分配。
3、分配在堆区，一般使用特定的函数进行分配。

三、动态分配函数

3.1 malloc

malloc 是一个系统函数，它是 memory allocate 的缩写。其中memory是“内存”的意思，allocate是“分配”的意思。顾名思义 malloc 函数的功能就是“分配内存”。要调用它必须要包含头文件<stdlib.h>。它的原型为：

 #include <stdlib.h>
 void *malloc(unsigned int size);
 功能：在堆区开辟指定长度的空间，并且空间是连续的
 参数：
 size：要开辟的空间的大小
 返回值：
 成功：开辟好的空间的首地址
 失败：NULL

1、在调用malloc之后，一定要判断一下，是否申请内存成功。
2、如果多次malloc申请的内存，第1次和第2次申请的内存不一定是连续的。
3、使用malloc开辟空间需要保存开辟好的空间的首地址，但是由于不确定空间用于做什么，所以本身返回值类型为void *，所以在调用函数时根据接收者的类型对其进行强制类型转换。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
int main()
{
 
	//向内存申请10个整型的空间
	int* p = (int*)malloc(10 * sizeof(int));
	if (p == NULL)
	{
		//打印错误原因的一个方式
		printf("%s\n", strerror(errno));
	}
	else
	{
		//正常使用空间
		int i = 0;
		for (i = 0; i < 10; i++)
		{
			*(p + i) = i;
		}
		for (i = 0; i < 10; i++)
		{
			printf("%d ", *(p + i));
		}
	}
	return 0;
}

结果
在这里插入图片描述

#include <stdio.h>
#include <stdlib.h>
 
char *fun()
{
    //char ch[100] = "hello world";
 
    //静态全局区的空间只要开辟好，除非程序结束，否则不会释放，所以
    //如果是临时使用，不建议使用静态全局区的空间
    //static char ch[100] = "hello world";
 
    //堆区开辟空间，手动申请手动释放，更加灵活
    //使用malloc函数的时候一般要进行强转
    char *str = (char *)malloc(100 * sizeof(char));
    str[0] = 'h';
    str[1] = 'e';
    str[2] = 'l';
    str[3] = 'l';
    str[4] = 'o';
    str[5] = '\0';
 
    return str;
}
 
int main(int argc, char *argv[])
{
    char *p;
    p = fun();
    printf("p = %s\n", p);
 
    //使用free函数释放空间
    free(p);
    //防止野指针
    p = NULL;
 
    return 0;
}

结果
在这里插入图片描述

3.2 free

C语言提供了另外一个函数free，专门是用来做动态内存的释放和回收的，函数原型如下：

 #include <stdlib.h>
 void free(void *ptr)
 功能：释放堆区的空间
 参数：
 ptr：开辟后使用完毕的堆区的空间的首地址
 返回值：
 无

注意：
free函数只能释放堆区的空间，其他区域的空间无法使用free
free释放空间必须释放malloc或者calloc或者realloc的返回值对应的空间，不能说只释放一部分
free§; 注意当free后，因为没有给p赋值，所以p还是指向原先动态申请的内存。但是内存已经不能再用了，p变成野指针了，所以一般为了放置野指针，会free完毕之后对p赋为NULL。
一块动态申请的内存只能free一次，不能多次free。

//使用free函数释放空间
ferr(p);
//防止野指针
p=NULL;

malloc和free都声明在 stdlib.h 头文件中

#include <stdio.h>
#include <stdlib.h>
int main()
{
 //代码1
 int num = 0;
 scanf("%d", &num);
 int arr[num] = {0};
 //代码2
 int* ptr = NULL;
 ptr = (int*)malloc(num*sizeof(int));
 if(NULL != ptr)//判断ptr指针是否为空
 {
 int i = 0;
 for(i=0; i<num; i++)
 {
 *(ptr+i) = 0；
 }
 }
 free(ptr);//释放ptr所指向的动态内存
 ptr = NULL;//是否有必要？
 return 0;
}
//有必要！
//当我们把空间还给操作系统时，
//但是p还是指向了这块空间，有被破坏的可能性，
//所以我们主动把p赋值给空指针，更加安全。
//malloc和free一定要成对使用。
//彻底不再需要这块空间时，就使用free函数。

3.3 calloc

C语言还提供了一个函数叫 calloc ， calloc 函数也用来动态内存分配。原型如下：

 #include <stdlib.h>
 void * calloc(size_t nmemb,size_t size);
 功能：在堆区申请指定大小的空间
 参数：
 nmemb：要申请的空间的块数
 size：每块的字节数
 返回值：
 成功：申请空间的首地址
 失败：NULL

注意：
malloc和calloc函数都是用来申请内存的。
区别：
1) 函数的名字不一样
2) 参数的个数不一样
3) malloc申请的内存，内存中存放的内容是随机的，不确定的，而calloc函数申请的内存中的内容为0
例如：
char *p=(char *)calloc(3,100);
在堆中申请了3块，每块大小为100个字节，即300个字节连续的区域。

 int main()
 {
 int *p = calloc(10, sizeof(int));
 if(NULL != p)
 {
//使用空间
 }
 free(p);
 p = NULL;
 return 0;
 }

3.4 realloc

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

有时会我们发现过去申请的空间太小了，有时候我们又会觉得申请的空间过大了，那为了合理的时候内存，我们一定会对内存的大小做灵活的调整。
那 realloc 函数就可以做到对动态开辟内存大小的调整。
函数原型如下：

 #include <stdlib.h>
 void* realloc(void *s,unsigned int newsize);
 功能：在原本申请好的堆区空间的基础上重新申请内存，新的空间大小为函数的第二个参数
 如果原本申请好的空间的后面不足以增加指定的大小，系统会重新找一个足够大的位
 置开辟指定的空间，然后将原本空间中的数据拷贝过来，然后释放原本的空间
 如果newsize比原先的内存小，则会释放原先内存的后面的存储空间，
 只留前面的newsize个字节
 参数：
 s：原本开辟好的空间的首地址
 newsize：重新开辟的空间的大小
 返回值：
 新的空间的首地址

这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到新的空间。
realloc在调整内存空间的是存在两种情况：
情况1：原有空间之后有足够大的空间
情况2：原有空间之后没有足够大的空间
在这里插入图片描述
情况1 当是情况1 的时候，要扩展内存就直接原有内存之后直接追加空间，原来空间的数据不发生变化。
情况2 当是情况2 的时候，原有空间之后没有足够多的空间时，扩展的方法是：在堆空间上另找一个合适大小的连续空间来使用。
这样函数返回的是一个新的内存地址。
由于上述的两种情况，realloc函数的使用就要注意一些。

#include <stdio.h>
int main()
{
 int *ptr = malloc(100);
 if(ptr != NULL)
 {
     //业务处理
 }
 else
 {
     exit(EXIT_FAILURE);    
 }
 //扩展容量
 //代码1
 ptr = realloc(ptr, 1000);//这样可以吗？(如果申请失败会如何？)
 //会有特别大的风险！
 
 //代码2
 int*p = NULL;
 p = realloc(ptr, 1000);
 if(p != NULL)
 {
 ptr = p;
 }
 //业务处理
 free(ptr);
 return 0;
}

这里如果对第一个指针直接进行realloc，会有非常大的风险。
如果发生情况2：原有空间之后没有足够大的空间，
那么我们会重新找一块空间分配，然后把旧的数据拷贝过来。
从感受上来看，我们的空间变大了，
但是返回的新地址和原来的地址不一定相同。
减少空间：

char *p;
2 p=(char *)malloc(100) 3 
//想重新申请内存,新的大小为50个字节
p=(char *)realloc(p,50);//p指向的内存的新的大小为50个字节,100个字节的后50个字
节的存储空间就被释放了

注意:malloc calloc relloc 动态申请的内存，只有在free或程序结束的时候才释放。

四、常见的动态内存错误

对NULL指针的解引用操作

void test()
{
 int *p = (int *)malloc(INT_MAX/4);
 *p = 20;//如果p的值是NULL，就会有问题
 free(p);
}

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

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

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

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

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

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

对同一块动态内存多次释放

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

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

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

忘记释放不再使用的动态开辟的空间会造成内存泄漏。切记：动态开辟的空间一定要释放，并且正确释放。

五、经典试题

题目1：

#include <stdio.h>
#include <stdlib.h>
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;
}

请问运行Test 函数会有什么样的结果？
结果
在这里插入图片描述
并没有像我们想的那样，输出hello world，
代码其实崩溃了。
崩溃的原因在于：
在GetMemory运行时，
把str传递给p,
但p是传值传递过来的，p是str的一份临时拷贝。
然后我们把一个动态开辟的地址放进p里；
但是这个地址并没有放到str里，
当GETMEMORY函数运行完，
临时变量p就销毁了，地址也没人记得了。
也就是说，str还是一个空指针。
也没法把字符串拷贝到空指针中，
所以程序崩溃。
而且程序存在内存泄漏的问题，
str以值传递的形式给p，p是GETMEMORY的一个形参，只在函数内部有效，
等GETMEMORY函数返回之后，动态开辟内存尚未释放，并且无法找到，
所以会造成内存泄漏。
这里改进，可以用二级指针：

#include <stdio.h>
#include <stdlib.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;
}

int main()
{
	Test();
	return 0;
}