C语言进阶--动态内存管理

目录

一.为什么使用动态内存分配?

二.动态内存函数

2.1.malloc和free

malloc函数

free函数

2.2.calloc和realloc

calloc函数

realloc函数

三.常见的动态内存错误

对NULL指针的解引用

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

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

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

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

动态开辟内存忘记释放

内存泄漏

四.经典笔试题

题一:

题二:

题三:

题四:

五.C/C++程序的内存开辟

六.柔性数组

6.1.柔性数组的特点

6.2.柔性数组的使用

6.3.柔性数组的优势

6.4.柔性数组的优势


一.为什么使用动态内存分配?

我们已经掌握的内存开辟方式有:

int val = 20; //在栈空间上开辟4个字节
char arr[10] = { 0 }; //在栈空间上开辟10个字节的连续空间

上述开辟空间的方式有两个特点:

  1. 空间开辟大小是固定的;
  2. 数组在申明的时候,必须指定数组的长度,它所需要的内存在编译时分配。

但是对于空间的需求,不仅仅是上述的情况。有时候我们需要的空间大小在程序运行的时候才能知道,那数组编译时开辟空间的方式就不能满足了。这时候就只能试试动态内存开辟了。

二.动态内存函数

2.1.malloc和free

C语言库函数提供了两个函数:malloc和free,分别用于执行动态内存分配和释放。这些函数维护一个可用内存池。当一个程序另外需要一些内存时,它就调用malloc函数,malloc从内存池中提取一块合适的内存,并向该函数返回一个指向这块内存的指针。这块内存此时并没有以任何方式进行初始化。如果对这块内存进行初始化非常重要,你要么自己动手对它进行初始化,要么使用calloc函数。当一块以前分配的内存不再使用时,程序调用free函数把它归还给内存池供以后之需。

malloc函数

函数原型:void* malloc(size_t size);

头文件:#include

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

  1. 如果开辟成功,则返回一个指向开辟好空间的指针;
  2. 如果开辟失败,则返回一个NULL指针,因此malloc的返回值一定要做检查;
  3. 返回值的类型是void*,所以malloc函数并不知道开辟空间的类型,具体在使用的时候使用者自己决定;
  4. 如果参数size为0,malloc的行为是标准未定义的,取决于编译器。

free函数

函数原型:void free(void* ptr);

头文件:#include

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

  1. 如果参数ptr指向的空间不是动态开辟的,那free函数的行为是未定义的;
  2. 如果参数ptr是NULL指针,则函数什么事都不做。

free函数的实际参数必须是先前由内存分配函数返回的指针。(参数也可以是空指针,此时free调用不起作用。)如果参数是指向其他对象(比如变量或数组元素)的空指针,可能会导致未定义的行为。虽然free函数允许收回不再需要的内存,但是使用此函数会导致一个新的问题:悬空指针。 调用free(p)函数会释放p指向的内存块,但是不会改变p本身。如果忘记了p不再指向有效内存块,混乱可能随即而来。试图访问或修改释放掉的内存块会导致未定义的行为。试图修改释放掉的内存块可能会引起程序崩溃等损失惨重的后果。

在C语言中,指针测试真假的方法和数的测试一样。所有非空指针都为真,而只有空指针为假。因此,语句if (p == NULL)可以写成if(!p),if (p != NULL)可以写成if(p)

案例一:

int main()
{
	//申请空间
	int* ptr = (int*)malloc(40);
	
	if (ptr == NULL)
	{
		perror("malloc");
		return 1;
	}

	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(ptr + i) = i;//ptr的指向并没有发生变化
	}

	//释放空间
	free(ptr);
	ptr = NULL;

	return 0;
}

分析:

在调用完free函数之后,如果不加上ptr==NULL,虽然free(ptr)函数会释放ptr指向的内存块,但是不会改变ptr本身。这就将导致一个新问题:悬空指针。

为了避免这个问题的发生,我们可以在free(ptr)之后将其置为NULL即可。

不加ptr==NULL释放前:

C语言进阶--动态内存管理_第1张图片

C语言进阶--动态内存管理_第2张图片

不加ptr==NULL释放后:

C语言进阶--动态内存管理_第3张图片

ptr==NULL释放后:

C语言进阶--动态内存管理_第4张图片

案例二:

int main()
{
	//申请空间
	int* ptr = (int*)malloc(40);
	int* p = ptr;

	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}

	//使用
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*p = i;
		p++;//p的指向发生变化
	}

	//释放空间
	free(ptr);
	ptr = NULL;

	if (ptr != NULL)
	{
		*ptr = 100;
	}

	return 0;
}

案例三:失败案例

int main()
{
	int* ptr = (int*)malloc(40);
	int* p = ptr;

	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}

	free(p);
	p=NULL;

	return 0;
}

分析:

free函数的实际参数必须是先前由内存分配函数返回的指针ptr。如果参数是指向其他对象(比如变量或数组元素)的空指针,可能会导致未定义的行为。

总结:

  1. 当我们不释放动态申请的内存时;
  2. 如果程序结束,动态申请的内存由操作系统自动回收;
  3. 如果程序不结束,动态内存是不会自动回收的,就会形成内存泄漏的问题。

2.2.calloc和realloc

calloc函数

函数原型:void* calloc(size_t num, size_t size);

头文件:#include

calloc函数为num个元素的数组分配内存空间,其中每个元素的长度都是size个字节。如果要求的空间无效,那么此函数返回空指针。在分配了内存之后,calloc函数会通过把所有位设置为0的方式进行初始化。

malloc和calloc之间的主要区别是后者在返回指向内存的指针之前把它初始化为0。calloc和malloc之间另一个较小的区别是它们请求内存数量的方式不同。calloc的参数包括所需元素的数量和每个元素的字节数。

案例:

int main()
{
	//malloc申请的空间不会被初始化为0
	//int* p = (int*)malloc(40);
	//申请10个整型的空间

	//calloc申请的空间会被初始化为0
	int* p = calloc(10, sizeof(int));//10为元素的个数,sizeof(int)为元素的大小
	
	if (p == NULL)
	{
		perror("calloc");
		return 1;
	}

	//使用
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ",*(p+i));
	}

	free(p);
	p = NULL;

	return 0;
}

调试分析:

C语言进阶--动态内存管理_第5张图片

realloc函数

函数原型:void* realloc(void* ptr, size_t size);

头文件:#include

当调用realloc函数时,ptr必须指向先前通过malloc,calloc或realloc的调用获得的内存块。size表示内存块的新尺寸,新尺寸可能会大于或小于原有尺寸。

realloc函数用于修改一个原先已经分配的内存块的大小。使用这个函数,你可以使一块内存扩大或缩小。如果它用于扩大一个内存块,那么这块内存原来的的内容依然保留,新增的内容添加到原先内存块的后面,新内存并未以任何方法进行初始化如果它用于缩小一个内存块,该内存块尾部的部分内存便被拿掉,剩余部分内存的原先内容依然保留

如果原先的内存块无法改变大小,realloc将分配另一块正确的大小,并把原来那块内存的内容复制到新的块上。因此,在使用realloc之后,你就不能再使用指向旧内存的指针,而是应该改用realloc所返回的新指针。

最后,如果realloc函数的第1个参数是NULL,那么它的行为就和malloc一模一样。如果realloc函数被调用时以0作为第二个实际参数,那么它会释放掉内存块

C语言进阶--动态内存管理_第6张图片

案例:

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

	//空间不够,希望能放20个元素,考虑扩容
	int* ptr = realloc(p, 80);

	if (ptr != NULL)
	{
		p = ptr;
	}

	//扩容成功,开始使用
	for (i = 10; i < 20; i++)
	{
		*(p + i) = i;
	}

	//不再使用,释放
	free(p);
	p = NULL;

	return 0;
}

 调试分析:

1.首先malloc分配40位的空间,也就是10个int型大小:

C语言进阶--动态内存管理_第7张图片

2.然后进行扩容,该扩容是在原空间的基础上进行的:

C语言进阶--动态内存管理_第8张图片

3.扩容成功后,则开始使用该空间:

C语言进阶--动态内存管理_第9张图片

4.使用完之后,则开始释放空间:

C语言进阶--动态内存管理_第10张图片

小结:

如何接收realloc的返回值?如果用旧地址去接收,那么当realloc找不到合适的空间进行内存分配时,这时realloc的返回值将变成NULL。此时不仅空间没有开辟好,原有空间的内容也可能丢失。那么我们应该打印错误信息然后结束程序,不要再往下执行。所以建议先用新地址接收,如果开辟成功再把它赋值给旧地址,这样就可以避免原有内存块数据的丢失。

三.常见的动态内存错误

对NULL指针的解引用

案例:

int main()
{
	int* p = (int*)malloc(1000);

	int i = 0;
	for (i = 0; i < 250; i++)
	{
		*(p + i) = i;
	}
	
	free(p);
	p=NULL;

	return 0;
}

分析:

malloc的返回值可能为NULL,此时将NULL赋值给指针p,则p的值也为NULL。然而后面又对p进行解引用,也就是对指针NULL进行解引用,此时的编译器将会发生警告。

解决办法:对malloc函数的返回值进行判断

改正:

int main()
{
	int* p = (int*)malloc(1000);

	//对p进行判空操作
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}

	int i = 0;
	for (i = 0; i < 250; i++)
	{
		*(p + i) = i;
	}
	
	free(p);
	p=NULL;

	return 0;
}

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

案例:

int main()
{
	int* p = (int*)malloc(1000);

	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}

	int i = 0;
	//可能越界访问
	for (i = 0; i <= 250; i++)
	{
		*(p + i) = i;
	}

	free(p);
	p = NULL;

	return 0;
}

分析:

i <= 250这个条件判断错误,数组产生越界,i的值应该小于250。

解决办法:对内存边界要检查

改正:

int main()
{
	int* p = (int*)malloc(1000);

	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}

	int i = 0;
	//可能越界访问
	for (i = 0; i < 250; i++)
	{
		*(p + i) = i;
	}

	free(p);
	p = NULL;

	return 0;
}

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

案例:

int main()
{
	int a = 10;
	int* p = &a;

	free(p);
	p = NULL;

	return 0;
}

分析:

free只能释放由malloc,calloc和realloc所开辟的内存空间,这些空间都是在堆区上进行开辟的。而变量a是在栈区开辟的,因此并不能让free来释放。

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

案例:

int main()
{
	int* p = (int*)malloc(1000);
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}

	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*p = i;
		p++;
	}

	//释放空间
	free(p);
	p = NULL;

	return 0;
}

分析:

随着p++的执行,指针p的位置已经发生了变化,不再指向所开辟内存空间的起始位置,而是指向中间的某个位置。而free又是从所开辟内存空间的起始位置开始释放的,所以free(p)用在这里显然是不合适的。

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

案例:

int main()
{
	int* p = (int*)malloc(1000);
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}

	free(p);
	
	//...

	free(p);

	return  0;
}

分析:

第一次free(p)时,此时所开辟的内存空间将会被释放,但是不会改变p本身,它还保存着之前所开辟内存空间的起始地址。所以我们要及时将p置为NULL,才能避免多次释放所带来的问题。

改正:

int main()
{
	int* p = (int*)malloc(1000);
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}

	free(p);
	p = NULL;

	//...

	free(p);//当参数为NULL时,此时free调用不起作用

	return  0;
}

动态开辟内存忘记释放

案例:

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

int main()
{
	test();
	while (1)
	{
		;
	}

	return 0;
}

分析:

p是一个局部变量,本来存放的是malloc所开辟内存空间的起始地址,但是当test函数调用完之后,变量p将会被释放。所以后面就没人再记得之前所开辟内存的起始地址,这将会导致内存泄漏。忘记释放不再使用的动态开辟的空间会造成内存泄漏。切记:动态开辟的空间一定要释放,并且正确释放。

改正:

void test()
{
	int* p = (int*)malloc(100);

	if (NULL != p)
	{
		*p = 20;
	}

	free(p);
	p = NULL;
}

int main()
{
	test();
	while (1)
	{
		;
	}

	return 0;
}

内存泄漏

当动态分配的内存不再需要使用时,它应该被释放,这样它以后可以被重新分配使用。分配内存但在使用完毕后不释放将引起内存泄漏。在那些所有执行程序共享一个通用内存池的操作系统中,内存泄漏将一点点地榨干可用内存,最终使其一无所有。要摆脱这个困境,只能重启系统。

四.经典笔试题

题一:

void GetMemory(char* p)
{
	p = (char*)malloc(100);
}

void Test(void)
{
	char* str = NULL;
	GetMemory(str);
	strcpy(str, "hello world\n");
	printf(str);
}

int main()
{
	Test();

	return 0;
}

分析:

  1. GetMemory(str):属于值传递,实参str传给形参p,形参p其实是实参的一份临时拷贝,所以对形参p的修改并不会影响到实参str,形参p调用完之后会自动销毁,所以str的值仍为NULL;
  2. p = (char*)malloc(100):会造成内存泄漏,因为malloc之后没有free。malloc分配的内存空间的地址存放在形参p中,所以当形参p销毁之后,也就没人知道malloc所分配的内存空间的起始地址,因而也就无法释放,最终会造成内存泄漏。

改正:

方案一:

void GetMemory(char** p)
{
	*p = (char*)malloc(100);
}

void Test()
{
	char* str = NULL;
	GetMemory(&str);

	strcpy(str, "hello world");

	printf(str);

	free(str);
	str = NULL;
}

int main()
{
	Test();

	return 0;
}

方案二:

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 main02()
{
	Test();

	return 0;
}

题二:

char* GetMemory(void)
{
	char p[] = "hello world";
	return p;
}

void Test(void)
{
	char* str = NULL;
	str = GetMemory();
	printf(str);
}

int main()
{
	Test();

	return 0;
}

运行结果:

分析:

  1. char p[] = "hello world":p是数组名,是一个临时变量,表示的是数组首元素的地址。而局部变量是在栈区开辟,函数调用完之后就会自动销毁,此时变量p将返回这个字符串的起始地址,但是该起始地址所指向的字符串的内容已销毁;
  2. str = GetMemory():此时将变量p赋值给变量str,而变量p已经变成野指针,它所指向的空间并不存放字符串"hello world",因此会造成非法访问内存;
  3. 返回栈空间地址的问题:栈空间的地址不要随意返回,会产生野指针。

改正:

char* GetMemory(void)
{
	char* p = "hello world";
	return p;
}

void Test(void)
{
	char* str = NULL;
	str = GetMemory();
	printf(str);
}

int main()
{
	Test();

	return 0;
}

题三:

void GetMemory(char** p, int num)
{
	*p = (char*)malloc(num);
}

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

int main()
{
	Test();

	return 0;
}

分析:

在调用GetMemory()函数时,由malloc函数开辟的内存空间在使用完后并没有及时地使用free进行释放,因而造成了内存泄漏。

改正:

void GetMemory(char** p, int num)
{
	*p = (char*)malloc(num);
}

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

int main()
{
	Test();

	return 0;
}

题四:

void Test(void)
{
	char* str = (char*)malloc(100);
	strcpy(str, "hello");
	free(str);

	if (str != NULL)
	{
		strcpy(str, "world");
		printf(str);
	}
}

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

分析:

在使用free释放由malloc所开辟的空间,虽然所开辟的空间已被释放,但是str依旧保存着所开辟空间的起始地址,这将导致指针悬空。如果忘记str不再指向有效内存块,此时刻试图访问或修改释放掉的内存块会导致未定义的行为。试图修改释放掉的内存块可能会引起程序崩溃等损失惨重的后果。

改正:

void Test(void)
{
	char* str = (char*)malloc(100);
	strcpy(str,"hello");
	free(str);

	//指针置为空
	str = NULL;

	if (str != NULL)
	{
		strcpy(str," world");
		printf(str);
	}
}

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

五.C/C++程序的内存开辟

规定:

  1. 栈区(stack):在执行函数时,函数内局部变量的存储单元都可以在栈上创建,函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中,效率很高,但是分配的内存容量有限。栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等;
  2. 堆区(heap) :一般由程序员分配释放,若程序员不释放,程序结束时可能由OS回收。分配方式类似于链表;
  3. 数据段(静态区)(static):存放全局变量、静态数据。程序结束后由系统释放;
  4. 代码段:存放函数体(类成员函数和全局函数)的二进制代码。

六.柔性数组

C99中,结构中的最后一个元素允许是未知大小的数组,这就叫做柔性数组成员,但结构中的柔性数组成员前面必须至少有一个其他成员。

例如:

struct S
{
	int num;
	double d;
	int arr[0];//柔性数组成员
};

有些编译器会报错无法编译,可以改成:

struct S
{
	int num;
	double d;
	int arr[];//柔性数组成员
};

6.1.柔性数组的特点

1.结构中的柔性数组成员前面必须至少一个其他成员;

2.sizeof返回的这种结构大小不包括柔性数组的内存;

struct S3
{
	int num;
	int arr[0];//柔性数组成员
};

int main()
{
	printf("%d\n",sizeof(struct S3));//4

	return 0;
}

3.包含柔性数组成员的结构用malloc()函数进行内存的动态分配,并且分配的内存应该大于结构的大小,以适应柔性数组的预期大小。

6.2.柔性数组的使用

柔性数组可以结合malloc进行使用,用以动态开辟内存空间;同时也可以结合realloc进行使用,用以内存空间的扩容。

案例:

struct S3
{
	int num;
	int arr[0];//柔性数组成员
};

int main()
{
	printf("%d\n",sizeof(struct S3));//4

	//开辟空间
	struct S3* ps = (struct S3*)malloc(sizeof(struct S3) + 40);//40用于柔性数组成员

	//判空
	if (ps == NULL)
	{
		perror("malloc");
		return 1;
	}

	//使用
	ps->num = 100;
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		ps->arr[i] = i;
	}

	//打印
	for (i = 0; i < 10; i++)
	{
		printf("%d ",ps->arr[i]);
	}

	//扩容
	struct S3* ptr = (struct S3*)realloc(ps, sizeof(struct S3) + 80);

	//判空
	if (ptr == NULL)
	{
		perror("realloc");
		return 1;
	}
	else
	{
		ps = ptr;
	}

	//使用
	for (i = 10; i < 20; i++)
	{
		ps->arr[i] = i;
	}

	//继续打印
	for (i = 10; i < 20; i++)
	{
		printf("%d ", ps->arr[i]);
	}


	//释放
	free(ps);
	ps = NULL;

	return 0;
}

6.3.柔性数组的优势

前面我们讲到可以使用柔性数组来动态开辟内存空间,这里我们将其改写成使用动态数组来开辟内存空间。示例如下:

struct S4
{
	int num;
	int* arr;
};

int main()
{
	//开辟空间
	struct S4* ps = (struct S4*)malloc(sizeof(struct S4));

	//判空
	if (ps == NULL)
	{
		perror("malloc");
		return 1;
	}
	
	//为动态数组开辟空间
	ps->arr = (int*)malloc(40);

	//判空
	if (ps->arr == NULL)
	{
		perror("malloc");
		return 1;
	}

	//使用
	ps->num = 100;
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		ps->arr[i] = i;
	}

	//打印
	for (i = 0; i < 10; i++)
	{
		printf("%d ", ps->arr[i]);
	}

	//扩容
	int* ptr = (int*)realloc(ps->arr, 20 * sizeof(int));

	//判空
	if (ptr == NULL)
	{
		perror("realloc");
		return 1;
	}
	else
	{
		ps->arr = ptr;
	}

    //使用
	for (i = 10; i < 20; i++)
	{
		ps->arr[i] = i;
	}

	//继续打印
	for (i = 10; i < 20; i++)
	{
		printf("%d ", ps->arr[i]);
	}


	//释放
	free(ps->arr);
	ps->arr = NULL;

	//释放
	free(ps);
	ps = NULL;

	return 0;
}

可以发现,改用动态数组的方式同样可以达到与使用柔性数组一样的效果。那二者有何差异呢?

C语言进阶--动态内存管理_第11张图片

通过对比可以发现:

  1. 当使用柔性数组来开辟和释放内存空间时,需要一次malloc和一次free
  2. 当使用动态数组来开辟和释放内存空间时,需要两次malloc和两次free
  3. 当使用柔性数组时,结构体所开辟的内存空间是连续的;当使用动态数组时,结构体所开辟的内存空间不一定是连续的;
  4. 当重复多次使用malloc函数,会在内存空间产生较多的内存碎片,进而导致内存的利用率降低。

6.4.柔性数组的优势

一.方便内存释放:

如果我们的代码是在一个给别人用的函数中,你在里面做了二次内存分配,并把整个结构体返回给用户。用户调用free可以释放结构体,但是用户并不知道这个结构体内的成员也需要free,所以你不能指望用户来发现这个事。所以,如果我们把结构体的内存以及其成员要的内存一次性分配好了,并返回给用户一个结构体指针,用户做一次free就可以把所有的内存也给释放掉。

二.有利于访问速度:

连续的内存有益于提高访问速度,也有益于减少内存碎片。(其实,也没多高,反正你跑不了要用做偏移量的加法来寻址。)

你可能感兴趣的:(c语言,c语言)