拿捏动态内存分配！！！

Sheep Shaun

已于 2024-04-06 22:55:50 修改

阅读量1k

点赞数 33

文章标签： c语言 c++ 数据结构

于 2024-04-06 18:00:37 首次发布

本文链接：https://blog.csdn.net/2302_80357424/article/details/137432130

版权

几日不见，甚是想念
今天我们来拿捏动态内存分配，很重要哦
请添加图片描述

1. 为什么要有动态内存分配

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

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

但是上述的开辟空间的方式有两个特点：
• 空间开辟大小是固定的。
• 数组在申明的时候，必须指定数组的长度，数组空间⼀旦确定了大小不能调整
但是对于空间的需求，不仅仅是上述的情况。有时候我们需要的空间大小在程序运行的时候才能知道，那数组的编译时开辟空间的方式就不能满足了。C语言引入了动态内存开辟，让程序员自己可以申请和释放空间，就比较灵活了。

2. malloc和free

2.1 malloc

C语言提供了⼀个动态内存开辟的函数：

void* malloc (size_t size);

这个函数向内存申请⼀块连续可用的空间，并返回指向这块空间的指针。
• 如果开辟成功，则返回⼀个指向开辟好空间的指针。
• 如果开辟失败，则返回⼀个 NULL 指针，因此malloc的返回值⼀定要做检查。
• 返回值的类型是 void* ，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定。
• 如果参数 size 为0，malloc的行为是标准是未定义的，取决于编译器。
我们举个例子：

int* a=(int*)malloc(4*sizeof(int))

定义一个整型指针a，将malloc函数分配的4个int大小的内存空间的首地址赋给a。在这里，分配了4个int大小的内存空间，所以总共分配了4 * sizeof(int) 个字节的内存空间。

2.2 free

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

void free (void* ptr);

free函数用来释放动态开辟的内存。
• 如果参数 ptr 指向的空间不是动态开辟的，那free函数的行为是未定义的。
• 如果参数 ptr 是NULL指针，则函数什么事都不做。
malloc和free都声明在 stdlib.h 头文件中。
eg：

#include <stdio.h>
#include <stdlib.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) = 0；
 		}
 	}
 	free(ptr);//释放ptr所指向的动态内存
 	ptr = NULL;//是否有必要？
 	return 0;
}

在C语言中，将指针赋值为NULL通常用于显式地将指针指向空地址，即不指向任何有效的内存空间。这样做有几个好处：

避免野指针：当指针没有被正确初始化时，它可能包含一个随机的内存地址，这样就会导致野指针的问题。将指针赋值为NULL可以避免这种情况。
易于判断：在程序中，可以通过判断指针是否为NULL来确定指针是否有效。如果指针为NULL，表示指针没有指向有效的内存空间。
安全释放内存：在释放动态分配的内存后，将指针赋值为NULL可以避免出现悬空指针的问题，即指针仍然指向已经释放的内存空间。

因此，将指针赋值为NULL是一个良好的编程习惯，可以提高程序的健壮性和可维护性。
所以，你明白了吗？那是当然

3. calloc和realloc

3.1 calloc

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

void* calloc (size_t num, size_t size);

• 函数的功能是为 num 个大小为 size 的元素开辟⼀块空间，并且把空间的每个字节初始化为0。
• 与函数 malloc 的区别只在于 calloc 会在返回地址之前把申请的空间的每个字节初始化为全0
eg：

#include <stdio.h>
#include <stdlib.h>
int main()
{
 	int *p = (int*)calloc(10, sizeof(int));
 	if(NULL != p)
 	{
 		int i = 0;
 		for(i=0; i<10; i++)
 		{
 			printf("%d ", *(p+i));
 		}
 	}
 	free(p);
 	p = NULL;
 	return 0;
 }

输出结果：

0 0 0 0 0 0 0 0 0 0

所以如果我们对申请的内存空间的内容要求初始化，那么可以很方便的使用calloc函数来完成任务。

3.2 realloc

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

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

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

#include <stdio.h>
#include <stdlib.h>
int main()
{
 	int *ptr = (int*)malloc(100);
 	if(ptr != NULL)
 	{
 	//业务处理
 	}
 	else
 	{
 	return 1; 
 	}
 	//扩展容量
 
 	//代码1 - 直接将realloc的返回值放到ptr中
 	ptr = (int*)realloc(ptr, 1000);//这样可以吗？(如果申请失败会如何？)
 
 	//代码2 - 先将realloc函数的返回值放在p中，不为NULL，在放ptr中
 	int*p = NULL;
 	p = realloc(ptr, 1000);
 	if(p != NULL)
 	{
 	ptr = p;
 	}
 	//业务处理
 	free(ptr);
 	return 0;
}

代码1中直接将realloc的返回值放到ptr中是否可以？
- 这种做法是不安全的。如果realloc函数调用失败，返回NULL，那么ptr将会指向NULL，原先分配的内存空间也会丢失，导致内存泄漏。因此，建议在使用realloc函数时，应该先将返回值保存在一个临时指针变量中，以确保在分配失败时不会丢失原有的内存空间。
如果申请失败会如何？
- 如果realloc函数调用失败，返回NULL，表示内存重新分配失败。此时，原有的内存空间仍然有效，不会丢失。因此，在代码中应该根据realloc函数的返回值来判断内存重新分配是否成功，并做相应的处理。
代码2中先将realloc函数的返回值放在p中，不为NULL，再放到ptr中的做法是正确的。这样可以确保在内存重新分配成功时，ptr指向新分配的内存空间，避免了潜在的内存泄漏问题。

综上所述，建议在使用realloc函数时，遵循代码2中的做法，即先将realloc函数的返回值保存在一个临时指针变量中，再根据返回值进行适当的处理，以确保程序的稳定性和内存管理的正确性。
你get到了吗？

4. 常见的动态内存的错误

4.1 对NULL指针的解引用操作

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

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

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

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

在代码中，试图使用free(p)来释放一个指向局部变量a的指针p所指向的内存空间。这是不安全的行为，因为a是一个局部变量，它的内存空间是在栈上分配的，而不是通过malloc或calloc等动态内存分配函数分配的堆内存。因此，尝试使用free函数释放p指向的内存会导致未定义的行为，可能会导致程序崩溃或其他不可预测的结果。

在C语言中，free函数应该仅用于释放通过malloc、calloc或realloc等动态内存分配函数分配的堆内存，而不应该用于释放栈上或静态内存中的变量。

因此，对于提供的代码，应该避免在test函数中使用free函数来释放局部变量所指向的内存，以避免出现不确定的行为。

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

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

在提供的代码中，首先使用malloc函数动态分配了一个包含100个整数的内存空间，并将指向该内存空间的指针赋给了p。然后，通过p++操作使指针p指向了动态分配的内存空间中的下一个位置，而不再指向该内存块的起始位置。

接着，尝试使用free(p)来释放p所指向的内存空间。这种做法是不安全的。因为free函数要求传入的指针必须是通过malloc、calloc或realloc等函数返回的动态内存的起始地址，而不能是内存块中间的地址。因此，在这种情况下，将p递增后再传递给free函数会导致内存释放错误，可能导致程序崩溃或其他不可预测的结果。

因此，对于提供的代码，应该确保调用free函数时传入的指针是通过动态内存分配函数返回的内存块的起始地址，而不是内存块中间的地址。如果需要释放动态分配的内存空间，应该使用最初分配的指针来调用free函数，而不是对指针进行任何操作后再释放。

4.5 对同⼀块动态内存多次释放

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

在第二次调用free(p)时，再次尝试释放同一块内存空间。这种重复释放同一块内存空间的行为是不安全的。因为一块内存空间在被释放后应该不再被访问或释放，重复释放同一块内存可能导致内存错误，例如出现段错误或内存泄漏等问题。

应该避免重复释放同一块内存空间。在动态分配内存后，应该确保每块内存只被释放一次，避免重复调用free函数。如果需要多次释放内存空间，应该重新分配新的内存空间来进行释放，而不是重复释放同一块内存。

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

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

在main函数中，首先调用test函数，然后进入一个无限循环while(1)。这样的设计意味着程序将永远停留在循环中，不会终止。由于在test函数中动态分配的内存空间没有被释放，程序在运行过程中会一直占用这部分内存空间，直到程序被强制终止。
忘记释放不再使用的动态开辟的空间会造成内存泄漏。
切记：动态开辟的空间⼀定要释放，并且正确释放。

5. 动态内存经典笔试题分析

5.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 函数会有什么样的结果？
运行Test函数会导致未定义行为和潜在的程序崩溃。在Test函数中，首先声明了一个char*类型的指针str并将其初始化为NULL，然后调用GetMemory函数并传入str指针。在GetMemory函数中，虽然重新分配了内存空间并将地址赋给了p，但由于GetMemory函数中的p是传入参数的一个拷贝，对其进行重新赋值并不会改变原指针的值。因此，str指针仍然是NULL，并没有正确指向有效的内存空间。

接着在Test函数中，尝试使用strcpy函数将字符串"hello world"复制到str指针指向的内存空间中，由于str指针仍然是NULL，这个操作会导致未定义行为，可能会造成内存访问错误或段错误。最后尝试使用printf函数输出str指针指向的字符串，同样会出现问题，因为str指针没有正确指向有效的内存空间，可能会导致程序崩溃或输出无法预测的结果。

因此，运行Test函数会导致不确定的行为和潜在的程序崩溃。为了避免这种情况，需要在GetMemory函数中正确处理指针的分配，并确保在Test函数中使用的指针能够正确指向有效的内存空间。
修改后：

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

void Test(void)
{
    char *str = NULL;
    GetMemory(&str); // 传入指针的地址
    if (str != NULL)
    {
        strcpy(str, "hello world");
        printf("%s\n", str);
        free(str); // 释放内存
    }
}

5.2 题目2：

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

请问运行Test 函数会有什么样的结果？
运行Test函数会导致不确定的行为和潜在的程序崩溃。在GetMemory函数中，声明了一个char类型的字符数组p并初始化为字符串"hello world"，然后将p作为返回值返回。在C语言中，当函数返回一个局部变量的地址时，这个地址将会变得无效，因为局部变量在函数执行完毕后会被销毁，所以返回的地址实际上指向的是一个无效的内存空间。

在Test函数中，将GetMemory函数的返回值赋给str指针，实际上str指针指向了一个已经被销毁的内存空间，这会导致未定义行为。然后使用printf输出str指针指向的字符串，由于str指向的内存空间已经无效，这可能会导致程序崩溃或输出无法预测的结果。

因此，运行Test函数会导致不确定的行为和潜在的程序崩溃。要避免这种情况，应该确保返回的指针指向的内存空间在函数调用结束后仍然有效，或者在调用函数后及时将返回的数据复制到另一个有效的内存空间中。

修改后：

char* GetMemory(void)
{
    char *p = (char *)malloc(12); // 分配足够的内存空间来存储 "hello world" 和结尾的'\0'
    if (p != NULL)
    {
        strcpy(p, "hello world");
    }
    return p;
}

void Test(void)
{
    char *str = NULL;
    str = GetMemory();
    if (str != NULL)
    {
        printf("%s\n", str);
        free(str); // 释放内存
    }
}

5.3 题目3：

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

请问运行Test 函数会有什么样的结果？
运行Test函数会导致未定义行为，并可能引发运行时错误，特别是当尝试使用strcpy函数将字符串"hello"复制到str指向的内存区域时。

让我们逐步分析Test函数：

char *str = NULL; - 初始化一个字符指针str为NULL。
GetMemory(&str, 100); - 调用GetMemory函数，将str的地址传递给它，并请求分配100字节的内存。
在GetMemory函数中：

*p = (char )malloc(num); - 使用malloc分配num（这里是100）字节的内存，并将返回的地址存储在p中，即str指向的内存地址。 strcpy(str,
“hello”); - 尝试将字符串"hello"（包括末尾的空字符’\0’）复制到str指向的内存区域。
问题出现在这里：malloc函数返回的是void *类型，在C语言中，当你将其赋值给char *时，通常不需要显式类型转换（即(char
*)）。然而，在某些编译器和设置下，可能需要显式转换以避免警告。但这并不是问题的核心。
问题在于malloc只分配了100字节的内存，但没有初始化这块内存。在C语言中，malloc分配的内存区域的内容是未定义的，这意味着它可能包含任何值。当你尝试使用strcpy将字符串复制到这块内存时，如果这块内存中的某个位置恰好包含一个空字符（‘\0’），strcpy会误以为它已经达到了字符串的末尾，并可能在未写入整个"hello"字符串的情况下就停止复制。这会导致str指向的内存区域中的字符串不完整，并且可能包含垃圾字符。
更糟糕的是，如果malloc分配的内存区域中在"hello"字符串之前没有任何空字符，strcpy将会继续复制，直到它找到一个空字符或者超出分配的内存区域。这将导致缓冲区溢出，可能覆盖相邻的内存区域，引发不可预测的行为，包括程序崩溃、数据损坏或安全漏洞。
最后，printf(str);试图打印str指向的字符串。如果strcpy正常工作并且没有引发崩溃，这将输出"hello"。但由于前面提到的潜在问题，这行代码可能不会按预期工作。
要修复这个问题，你应该确保在调用strcpy之前，分配的内存区域被正确初始化为全零，或者使用更安全的字符串复制函数，如strncpy，并确保目标缓冲区足够大以容纳要复制的字符串及其末尾的空字符。同时，总是检查malloc是否成功分配了内存（即返回的不是NULL），并在不再需要内存时使用free释放它。
这个大家自己改改看~~

5.4 题目4：

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

请问运行Test 函数会有什么样的结果？
运行Test函数会导致未定义行为，并可能引发运行时错误。

分析Test函数中的代码：

char *str = (char *) malloc(100); 分配了100字节的内存给str指针，并假设分配成功（未检查malloc的返回值是否为NULL）。
strcpy(str, “hello”); 将字符串"hello"复制到str指向的内存中。由于已经分配了足够的内存，这通常是安全的。
free(str); 释放了str指向的内存。此时，str指针本身的值（即内存地址）并没有改变，但它指向的内存已经不再属于程序，并且可以被操作系统重新分配给其他进程。
if(str != NULL) 检查str是否不为NULL。由于之前我们只是释放了str指向的内存，并没有将str设置为NULL，所以这个条件始终为真。
strcpy(str, “world”); 尝试将字符串"world"复制到str指向的内存中。但是，此时str仍然指向已经被free释放的内存区域。这是一个严重的错误，因为程序现在尝试向一个不再属于它的内存区域写入数据。这可能会导致数据损坏、程序崩溃或其他不可预测的行为。
printf(str);尝试打印str指向的字符串。由于str指向的内存已经被释放，并且可能已经被修改，因此printf可能会输出乱码、崩溃或者表现出其他异常行为。

为了避免这个问题，你应该在调用free后立即将指针设置为NULL，以防止后续的误用。此外，始终检查malloc（以及calloc和realloc）的返回值是否为NULL，以确保内存分配成功.

6. 柔性数组*

也许你从来没有听说过柔性数组（flexible array）这个概念，但是它确实是存在的。
C99 中，结构中的最后⼀个元素允许是未知⼤⼩的数组，这就叫做『柔性数组』成员。

typedef struct st_type
{
 	int i;
	 int a[0];//柔性数组成员
}type_a;

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

typedef struct st_type
{
 	int i;
 	int a[];//柔性数组成员
}type_a;

6.1 柔性数组的特点：

• 结构中的柔性数组成员前面必须至少⼀个其他成员。
• sizeof 返回的这种结构大小不包括柔性数组的内存。
• 包含柔性数组成员的结构用malloc ()函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小。
例如：

typedef struct st_type
{
 int i;
 int a[0];//柔性数组成员
}type_a;
int main()
{
 printf("%d\n", sizeof(type_a));//输出的是4
 return 0;
}

6.2 柔性数组的使用

//代码1
#include <stdio.h>
#include <stdlib.h>
int main()
{
 	int i = 0;
 	type_a *p = (type_a*)malloc(sizeof(type_a)+100*sizeof(int));
 //业务处理
 	p->i = 100;
 	for(i=0; i<100; i++)
 	{
 		p->a[i] = i;
 	}
 	free(p);
 	return 0;
}

这样柔性数组成员a，相当于获得了100个整型元素的连续空间。

6.3 柔性数组的优势

上述的 type_a 结构也可以设计为下⾯的结构，也能完成同样的效果。
//代码2

#include <stdio.h>
#include <stdlib.h>
typedef struct st_type
{
 	int i;
 	int *p_a;
}type_a;
int main()
{
 	type_a *p = (type_a *)malloc(sizeof(type_a));
 	p->i = 100;
 	p->p_a = (int *)malloc(p->i*sizeof(int));
 
 //业务处理
 	for(i=0; i<100; i++)
 	{
 		p->p_a[i] = i;
 	}
 
 //释放空间
 	free(p->p_a);
 	p->p_a = NULL;
 	free(p);
 	p = NULL;
 	return 0;
}

上述代码1 和代码2 可以完成同样的功能，但是方法1 的实现有两个好处：
第⼀个好处是：方便内存释放

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

第二个好处是：这样有利于访问速度.

连续的内存有益于提高访问速度，也有益于减少内存碎片。（其实，我个人觉得也没多高了，反正你跑不了要用做偏移量的加法来寻址）

扩展阅读：
C语言结构体里的数组和指针

7. 总结C/C++中程序内存区域划分

C/C++程序内存分配的几个区域：

栈区（stack）：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时
这些存储单元⾃动被释放。栈内存分配运算内置于处理器的指令集中，效率很⾼，但是分配的内
存容量有限。栈区主要存放运⾏函数⽽分配的局部变量、函数参数、返回数据、返回地址等。
堆区（heap）：⼀般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收。分配方
式类似于链表。
数据段（静态区）（static）存放全局变量、静态数据。程序结束后由系统释放。
代码段：存放函数体（类成员函数和全局函数）的⼆进制代码
下面是一个简单的C语言代码示例，演示了不同内存区域的应用：

#include <stdio.h>
#include <stdlib.h>

// 全局变量，存放在数据段
int globalVar = 10;

// 函数定义
void func() {
    // 栈区内存分配
    int localVar = 20;
    
    // 堆区内存分配
    int* heapVar = (int*)malloc(sizeof(int));
    *heapVar = 30;
    
    printf("Local variable in stack: %d\n", localVar);
    printf("Heap variable: %d\n", *heapVar);
    
    // 释放堆区内存
    free(heapVar);
}

int main() {
    // 调用函数
    func();
    
    // 全局变量
    printf("Global variable: %d\n", globalVar);
    
    return 0;
}