C语言: 详细讲解动态内存管理

Length-vision

已于 2023-12-15 23:03:19 修改

阅读量829

点赞数 17

文章标签： c++ c语言

于 2023-12-12 17:24:34 首次发布

本文链接：https://blog.csdn.net/Lvision2/article/details/134949594

版权

文章目录

第一次用markdown写blog，有不好的地方请见谅or2 😘

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

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

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

但是上述的开辟空间的⽅式有两个特点：

空间开辟⼤⼩是固定的。
数组在申明的时候，必须指定数组的⻓度，数组空间⼀旦确定了⼤⼩不能调整
但是对于空间的需求，不仅仅是上述的情况。有时候我们需要的空间⼤⼩在程序运⾏的时候才能知道，那数组的编译时开辟空间的⽅式就不能满⾜了。
C语⾔引⼊了动态内存开辟，让程序员自己可以申请和释放空间，就⽐较灵活了。

2. malloc和free

malloc与free的头文件声明都为 #include<stdlib.h>

2.1 malloc

malloc的动态内存开辟的空间是在堆区申请的

语法：

1 void* malloc (size_t size);
size_t size - 开辟size字节的空间

这个函数向内存申请⼀块连续可⽤的空间，并返回指向这块空间的指针。
关于开辟malloc有以下几点需要特别注意：

int* ptr = (int*)malloc(10 * sizeof(int));
if (ptr == NULL)
{
	perror("ptr");
	return 1;
}

如果开辟成功，则返回⼀个指向开辟好空间的指针。
如果开辟失败，则返回⼀个 NULL 指针，因此malloc的返回值⼀定要做检查，否则开辟失败再使用会程序崩溃。如上代码所示，做一个if判断
返回值的类型是 void* ，所以malloc函数并不知道开辟空间的类型，具体在使⽤的时候，需要将其强制转换为自己需要的类型指针，如上做了（int*)…。
如果参数 size 为0，malloc的⾏为是标准是未定义的，取决于编译器。

2.2 free

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

void free (void* ptr);
ptr-malloc开辟的动态内存的指针

free函数⽤来释放动态开辟的内存，需要特别注意：

如果参数 ptr 指向的空间不是动态开辟的，那free函数的⾏为是未定义的。也就是说，参数ptr指向的空间必须是动态开辟的空间，否则会崩溃。
如果参数 ptr 是NULL指针，则函数什么事都不做。
还有一点特别特别要注意：ptr在free后，其指向依旧是原来的空间，而因为原来的空间已经还给了操作系统，此时ptr指向的是未被授权的空间，也就成了野指针，这是相当危险的，为了避免野指针的出现，我们free完一个指针后，一定要让其指向NULL。（只看加粗字体即可，未加粗为解释）

有借就有还，我们通过malloc申请了一块空间，使用完后，一定要通过free释放改内存，下面是一个malloc与free完整使用的例子;

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

3. calloc和realloc

3.1 calloc

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

void* calloc (size_t num, size_t size);
-num为需要类型的个数，-size为类型字节大小

与molloc的区别：在返回地址之前把申请的空间的每个字节初始化为全0

举个使用的例子：

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

运行结果为：

1 0 0 0 0 0 0 0 0 0 0

3.2 realloc

有时会我们发现过去申请的空间太⼩了，有时候我们⼜会觉得申请的空间过⼤了，那为了合理的时候内存，我们⼀定会对内存的⼤⼩做灵活的调整。

所以，realloc 函数就可以做到对动态开辟内存⼤⼩的调整。

函数原型如下：

void* realloc (void* ptr, size_t size);
ptr - 是要调整的内存地址
size -调整之后新⼤⼩

使用 realloc 有：两点需要注意：

返回值为调整之后的内存起始位置。
用 ptr2(另一指针) 接收其返回值，如果开辟失败，会返回NULL，在检验没有问题后才把这个指针交回给 ptr

realloc在调整内存空间的是存在两种情况：

情况1：原有空间之后有⾜够⼤的空间
情况2：原有空间之后没有⾜够⼤的空间

举个使用的例子：

#include <stdio.h>
#include<stdlib.h>
int main()
{
	char* ptr = (char*)malloc(10 * sizeof(char));
	int i = 0;
	if (ptr == NULL)
		return 1;
	else
	{
		for (i = 0; i < 10; i++)
		{
			*(ptr + i) = 'a';
		}
	}
	char* p2 = (char*)realloc(ptr, 15 * sizeof(char));
	if (p2 == NULL)
		return 1;
	else
	{
		ptr = p2;
		for (i = 10; i < 15; i++)
		{
			*(ptr + i) = 'b';
		}
	}
	for (i = 0; i < 15; i++)
	{
		printf("%c ", *(ptr + i));
	}
	free(ptr);
	p2 = NULL;
	ptr = NULL;
	return 0;
}

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

1.对NULL指针的解引⽤操作

void test()
 {
 int *p = (int *)malloc(INT_MAX/4);//如果p的值是NULL，程序会崩溃
 *p = 20;
 free(p);
 }

改正：加个if判断

void test()
{
	int* p = (int*)malloc(INT_MAX / 4);
	if (p == NULL)
		return 1;
	*p = 20;
	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);
 }

改正：调整for循环范围

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;
 }
 free(p);
 }

3. 对⾮动态开辟内存使⽤free释放

void test()
{
 int a = 10;
 int *p = &a;
 free(p);// 对⾮动态开辟内存使⽤free释放
 }

据上文使用free的注意可知：参数ptr指向的空间必须是动态开辟的空间，否则会崩溃

4. 使⽤free释放⼀块动态开辟内存的⼀部分

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

需要注意：进行free操作的指针，指向的必须是动态内存的起始位置

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

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

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

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

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

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

题⽬1：

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

分析问题：

调用GetMemory函数，将str的值交给了p，此时p的值为NUll。
在GetMemory函数中，malloc开辟的空间地址交给了形式指针p，但在函数执行完后，指针p的地址就被销毁了，会导致找不到malloc开辟的空间，出现内存泄漏的问题。
str在GetMemory函数执行后，并没有指向malloc开辟的空间地址，还是NULL，此时对str进行任何赋值操作，都会崩溃。

这样修改后就不会有问题，将&str交给二级指针p：

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

题⽬2：

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

分析问题：

在GetMemory建立的char p[ ]，离开函数是会销毁，就算return p给str，也会使str成为野指针。
没有free操作。

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

分析问题：没有free操作。

题⽬4：

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

分析问题：提前使用了free操作。

6. 柔性数组

语法：

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 柔性数组的使⽤

#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个整型元素的连续空间。

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

在这里插入在这里插入图片描述
图片描述
C/C++程序内存分配的⼏个区域：

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

Length-vision

关注

17
点赞
踩
14

收藏

觉得还不错? 一键收藏
0
评论
C语言: 详细讲解动态内存管理

C/C++程序内存分配的⼏个区域：栈区（stack）：在执⾏函数时，函数内局部变量的存储单元都可以在栈上创建，函数执⾏结束时这些存储单元⾃动被释放。栈内存分配运算内置于处理器的指令集中，效率很⾼，但是分配的内存容量有限。栈区主要存放运⾏函数⽽分配的局部变量、函数参数、返回数据、返回地址等。堆区（heap）：⼀般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收。分配⽅式类似于链表。数据段（静态区）:（static）存放全局变量、静态数据。程序结束后由系统释放。代码段。
复制链接

扫一扫