动态内存管理：灵活申请释放空间

原创 已于 2025-05-30 22:17:04 修改 · 808 阅读 · 24 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #android #开发语言

于 2025-05-26 23:04:08 首次发布

动态内存管理

为什么要有动态内存管理

我们目前掌握的内存开辟方式有：

int a = 0;//使用变量进行开辟四个字节
int arr[10] = { 0 }; //使用数组开辟40个字节的空间

以上的开辟有缺陷：
空间开辟大小是固定的
数组在声明的时候，指定了数组的长度，数组空间确定后无法改变，有时候大了浪费空间，有时候小了不够用
因此使用动态内存管理，可以让我们灵活的申请和释放空间

malloc和free

malloc和free使用时需要包含其头文件

#include<stdlib.h>

malloc

void* malloc (size_t size);

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

//使用malloc 申请10个整型的空间,并将其赋予值
#include<stdlib.h>
int main()
{
	int* p = (int*)malloc(10 * sizeof(int));
	//空间开辟失败
	if (p == NULL)
	{
		perror("malloc");//找出开辟空间失败原因
		return 1;//异常返回，结束程序运行
	}
	//开辟成功
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i + 1;
	}

	//用完后及时释放
	free(p);
	p = NULL;
	return 0;
}

malloc值得注意的点：

  1. 参数的单位是字节
  2. 申请空间成功的话，返回起始地址
    申请失败，返回NULL
  3. 返回值的类型是void*,在使用时可以将其强转成自己所需要的类型后使用
  4. malloc(0) 的结果取决于编译器，可能是 NULL 或无效指针
//开辟空间失败的案例,请在X86环境下测试
int main()
{
	int* p = (int*)malloc(INT_MAX);
	//空间开辟失败
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	//开辟成功
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i + 1;
	}

	//用完后及时释放
	free(p);
	p = NULL;
	return 0;
}

malloc所申请的空间和数组的空间有什么区别吗？

1.动态内存的大小是可以调整的
2.开辟空间的位置不一样，数组是存放在栈区的，而malloc是存放在堆区的

在这里插入图片描述

free

我们使用malloc向内存申请空间，如果我们不想用了，可以使用free函数对内存进行释放和回收

void free (void* ptr);

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

free的使用在下面代码的最后

//使用malloc 申请10个整型的空间,并将其赋予值
#include<stdlib.h>
int main()
{
	int* p = (int*)malloc(10 * sizeof(int));
	//空间开辟失败
	if (p == NULL)
	{
		perror("malloc");//找出开辟空间失败原因
		return 1;//异常返回，结束程序运行
	}
	//开辟成功
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i + 1;
	}

	//用完后及时释放
	free(p);
	p = NULL;
	return 0;
}

free函数需要注意的是：

  1. 如果参数ptr指向的空间不是动态开辟的，那free的行为是未定义的
  2. 如果参数ptr是指向的空间是NULL时，free函数什么事情也不做
//注意1.的假设案例(结论是上面的1.)
int main()
{
	int arr[10] = { 0 };
	int* p = arr;

	//.......
	free(p);//err
	p = NULL;
	return 0;
}

//注意2.的假设案例(结论是上面的2.)
int main()
{
	int* p = (int*)malloc(20 * sizeof(int));

	//.........//假设这里的还有代码需要运行
	p = NULL;
	//.......
	free(p);
	//这里的free(p)什么事情对不会做
	return 0;
}

那free对内存的释放和数组的释放有什么区别呢？

free释放有两种情况：

1. 程序员主动释放，用完这块空间后就释放（这是一个好的习惯）
2. 如果不释放的话，等到程序等到程序结束的时候也会被操作系统自动回收（不建议，如果一直申请空间，而不及时释放，会造成空间的浪费）

数组的释放就相对简单：程序运行结束后操作系统自动回收
malloc和free最好成对使用

calloc和realloc

calloc

void* calloc (size_t num, size_t size);

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

calloc和malloc的区别：

1.函数calloc比malloc多了一个参数，malloc是需要 个数 * 类型的，而calloc只需要输入个数 和 类型即可
2.函数calloc在返回所申请空间的起始地址之前，会将空间中的每个字节初始化为0

练习：使用calloc向内存的堆区申请20个整型的空间

int main()
{
	int* p = (int*)calloc(20, sizeof(int));

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

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

	free(p);
	p = NULL;
	return 0;
}

如果想要对申请空间的内容要求初始化的话，那么可以使用calloc完成

realloc

这个函数的功能是将原有的内存空间进行大小的调整。我们使用了前面所学的函数向堆区申请了一块空间，有时候大了会造成空间浪费；有时候小了不够用，这时，就需要用到这个函数了。有了该函数才使得动态内存管理更加灵活多变

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

ptr 是需要调整的内存起始地址，不能是一个空间的中间位置， 也就是前面使用malloc、calloc、前面一次使用realloc进行调整过的内存空间或者是一个空指针，这种情况下会分配一个新的内存空间（的起始地址）
size 是调整后的新内存空间的大小，单位是字节
这个函数的返回值 调整后的内存空间的起始地址，类型是void*，具体使用时可以强转成程序员自己想要的类型

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

情况一：原有空间的后面有足够大的空间
情况二：原有空间的后面没有足够大的空间
在这里插入图片描述
情况一
要扩展内存空间，就在原有的基础上在后面直接追加空间，并且原有的内存空间数据不变，返回的是原有的内存空间的起始地址

情况二
原有的内存空间后面的空间不够时，ralloc会直接在内存的堆区找一块新的满足大小的空间；会将旧的数据拷贝到新的空间；同时自动释放旧的空间，返回新内存空间的起始地址

因此在使用该函数时，我们需要创建一个新的指针变量去接收函数的返回值

realloc的扩展和缩小的方法是类似的，对参数 size 的大小进行相对应的调整
练习：
将之前向内存申请的20个整型的内存空间扩展到40个整型大小

int main()
{	
	int* p = (int*)calloc(20, sizeof(int));
	if (p == NULL)
	{
		perror("calloc");
		return 1;
	}

	int i = 0;

	for (i = 0; i < 20; i++)
	{
		printf("%d ", *(p + i));
	}
	int* ptr = (int*)realloc(p, 12 * sizeof(int));//验证情况一和二
	//用ptr的原因：防止将之前旧p的地址搞丢了
	//num 是个数，size 是内存空间的总字节个数
	if (ptr != NULL)//这里是为了验证它是是否扩展成功，如果想要缩小的话，就将前面的szie变小就行
	{
		p = ptr;
	}
	
	//使用 
	//..........
	//释放
	free(p);
	p = NULL;

	return 0;
}

realloc 也可以像内存申请一块空间

具体代码如下：

int main()
{
	int* p = (int*)realloc(NULL, 40);//==malloc(40)
	if (p == NULL)
	{
		perror("realloc");
		return 1;
	}

	//使用
	//.......
	//释放
	free(p);
	p = NULL;
	return 0;
}

常见的动态内存的错误

对NULL指针的解引用操作

int main()
{
	int* p = (int*)malloc(10 * sizeof(int));
	*p = 20;
	//如果这里是空指针就不行了，因此需要加以限制
	//以下是做出限制的内容
	/*if (p == NULL)
	{
		perror("malloc");
		return 1;
	}*/
	
	//代码的使用
	//........

	//释放
	free(p);
	p = NULL;
	return 0;
}

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

//对动态开辟空间的越界访问   --- 使用时超出所申请的空间
int main()
{
	int* p = (int*)calloc(10, sizeof(int));

	if (p == NULL)
	{
		perror("calloc");//这里是为了当申请空间失败后，找出错误的所在
		return 1;
	}

	int i = 0;
	for (i = 0; i < 40; i++)//这里搞了40个整型，但实际上却只有10个
	{
		printf("%d ", *(p + i));
	}

	free(p);
	p = NULL;
	return 0;
}

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

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

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

	free(p);
	p = NULL;
	return 0;
}

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

//使用free函数释放一块动态开辟内存的一部分 --- 释放的所开辟的动态内存空间需要找到其起始地址，这个所谓的错误就是将起始地址改变后再进行释放

int main()
{
	int* p = (int*)malloc(10 * sizeof(int));

	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	//p++;例子1

	//例子2：使用时将p的位置改变了
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*p = i;
		p++;
	}

	free(p);
	p = NULL;
	return 0;
}

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

int main()
{
	int* p = (int*)calloc(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);

	/*free(p);
	p = NULL;*///如果是前面有了释放和p = NULL，后面的再有这两个，那么后面的释放和p = NULL就什么也不会做
	
	free(p);//倘若前面只有一个释放，这里就造成了多次释放，程序会出现问题
	return 0;
}

动态开辟内存忘记释放(导致内存泄露)

//动态开辟内存忘记释放(导致内存泄露)
void test()
{
	int* p = (int*)calloc(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;
}

int main()
{
	test();
	while (1);//这里是假设还有程序在运行
	return 0;
	
}
动态内存管理是一把双刃剑，

他使内存空间变的灵活多变的同时，也带来了风险

动态内存管理经典题目

题目1

#include<stdio.h>
#include<stdlib.h>
void GetMemory(char* p)
{
	p = (char*)malloc(100);//错误2：向堆区申请空间后没有释放，造成内存泄露
}
//形参p接收str的空指针，由malloc向内存申请100个空间
void Test(void)
{
	char* str = NULL;
	GetMemory(str);//实参传给形参时，形参拥有自己独立的空间，这里的str还是NULL
	strcpy(str, "hello world");//错误1：在str中，对NULL指针解引用操作，程序就会崩溃
	printf(str);//这里的打印没有问题，
	//下面的程序是对打印正确的进一步说明
	//char* p = "hello world\n";
	//printf("hello world\n");//实际上printf中的参数传递的是字符串首字符的地址
	//printf(p);
}
int main()
{
	Test();
	return 0;
}
//改正：
#include<string.h>
void GetMemory(char** p)
{
	*p = (char*)malloc(100);

}
void Test(void)
{
	char* str = NULL;
	GetMemory(&str);//这里实际上是想将内存中申请的空间传给str，并且在str的空间中打印hello world，
	//那就将str作为变量传给p，解引用p就可将所申请的空间传给str
	strcpy(str, "hello world");
	printf(str);
	free(str);//使用完后需要对str进行释放
	str = NULL;
}


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

//改法2：//通过改变返回值，让str接收p，使得str 得到所申请的空间
#include<string.h>
char* GetMemory(char* p)
//char* GetMemory()//参数可要可不要，如果没有，p = (char*)malloc(100);要在p的前面加上(char*)
{
	p = (char*)malloc(100);
	return p;
}
void Test(void)
{
	char* str = NULL;
	str = GetMemory(str);//使用这个时，需要将改法1进行注释，否则会报错
	//str = GetMemory();
	strcpy(str, "hello world");
	printf(str);
	free(str);
	str = NULL;
}
int main()
{
	Test();
	return 0;
}

题目2

#include<stdio.h>
#include<stdlib.h>
//题目2：//返回栈空间地址的问题
char* GetMemory(void)
{
	char p[] = "hello world";
	return p;
}
//这里在函数中创建字符数组，因为函数在作用域结束时自动释放（栈内存特性），
 //所以返回p中字符串的起始地址(也就是返回函数栈中的地址)会成为野指针，使用野指针程序会崩溃
//解决办法：在函数中向堆区使用动态内存管理的函数进行申请空间，等到程序运行结束后进行手动释放
void Test(void)
{
	char* str = NULL;
	str = GetMemory();
	printf(str);
}

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

//改正：
#include<string.h>
char* GetMemory(void)
{
	char* p = (char*)malloc(20 * sizeof(char));
	if (p == NULL)
	{
		perror("malloc");
		return NULL;
	}
	strcpy(p, "hello world");
	return p;

}

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

	free(str);
	str = NULL;
}

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

//以下是的程序也是返回栈空间地址的问题
int* f1(void)
{
	int x = 10;
	return (&x);//出了函数就销毁，成了野指针
}

int* f2(void)
{
	int* ptr;//指针没有初始化，为野指针
	*ptr = 10;
	return ptr;
}

//这个程序是对的，因为函数在返回数的时候，程序会将10 存储到寄存器中，即使函数销毁了，n也能接收到
test()
{
	int a = 10;
	return a;
}

int main()
{
	int n = test();
	printf("%d\n", n);

	return 0;
}

//这个程序也是返回栈空间的问题
test()
{
	int a = 10;
	return &a;
}

int main()
{
	int n = test();
	printf("%d\n", n);

	return 0;
}

题目3

#include<stdio.h>
#include<stdlib.h>
//题目3：
#include<string.h>
void GetMemory(char** p, int num)
{
	*p = (char*)malloc(num);
}
void Test(void)
{
	char* str = NULL;
	GetMemory(&str, 100);
	strcpy(str, "hello");
	printf(str);
}

//这里的100个字节的空间是由malloc申请的，使用完后要及时释放，
// 这里没有释放，造成了内存泄漏
//将代码的执行流程以画图的形式展开
int main()
{
	Test();
	return 0;
}

//改法：
#include<string.h>
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(str);
	str = NULL;
}
int main()
{
	Test();
	return 0;
}

题目4

//题目4：
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
void Test(void)
{
	char* str = (char*)malloc(100);
	strcpy(str, "hello");
	free(str);
	//这里没有将str指向的空间进行置空，导致str 成为了野指针；
	if (str != NULL)
	{
		strcpy(str, "world");//同时也造成了这个str的非法访问
		printf(str);
	}
}


int main()
{
	Test(); 
	return 0;
}
//这个题目考察的是使用malloc向内存中申请空间，当你不想用这块空间了，
// 想要释放时是否将它进行置为空指针，防止使其成为野指针
//使用malloc需要进行判断它是否为空指针

//改法：
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;
}

柔性数组
在C99 中，结构中的最后⼀个元素允许是未知⼤⼩的数组，这就叫做柔性数组成员。

什么是柔性数组呢？
1,在结构体中
2. 最后一个成员
3. 未知大小的数组

举个小案例：

struct S
{
	int i;
	char c;
	double a;
	char arr[];//未知大小的数组 - arr就是柔性数组的成员
};

struct S
{
	int i;
	char c;
	double a;
	char arr[0];//未知大小的数组 - arr就是柔性数组的成员
};

//这两种写法在VS都支持

柔性数组的特点
结构中的柔性数组成员前⾯必须⾄少⼀个其他成员。
• sizeof 返回的这种结构⼤⼩不包括柔性数组的内存。

struct S
{
	int i;
	char arr[];
};
int main()
{
	printf("%zd\n", sizeof(struct S));//打印结果为4
	return 0;
}

• 包含柔性数组成员的结构⽤malloc ()函数进⾏内存的动态分配，并且分配的内存应该⼤于结构的⼤⼩，以适应柔性数组的预期⼤⼩。

struct S
{
	int i;
	char arr[];
};
int main()
{
	printf("%zd\n", sizeof(struct S));//打印结果为4
	return 0;
}

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

struct S
{
	int i;
	//char arr[];//数组的类型不同，其结果也不同，前面使用这个，和预期结果不同
	int arr[];//数组
};
int main()
{
	//假设我想要申请84个字节，其中柔性数组占80个字节
	struct S* str = (struct S*)malloc(sizeof(struct S) + 20 * sizeof(int));
	//sizeof(struct S) -- 利用了柔性数组特点
	//判断
	if (str == NULL)
	{
		perror("malloc");
		return 1;
	}

	//使用
	str->i = 520;
	int i = 0;
	for (i = 0; i < 20; i++)
	{
		printf("%d ", str->arr[i] = i + 1);
	}
	printf("\n");
	printf("%d\n", str->i);

	//通过上面的操作可知，我们前面学的数组的大小都是固定的，但现在不同，现在可以使用realloc可以实现数组大小的变化
	
	//这里是使用realloc改变数组的大小
	struct S* ps = (struct S*)realloc(str, sizeof(struct S) + 40 * sizeof(int));
	if (ps != NULL)
	{
		str = ps;
		ps = NULL;//将ps赋给str后防止ps成为野指针
	}
	else//如果申请失败，则异常返回
	{
		perror("realloc");
		return 1;
	}
	//这里的调整和前面学习动态内存管理的类似，只是类型成为了自定义类型
	
	//调整后使用

	
	
	for (i = 0; i < 40; i++)
	{
		printf("%d ", str->arr[i]);//这里的后20个整型类型的数据是随机的，因为后面的20个是调整后得到的
		//程序会报警告，实际上是正确的
	}
	printf("\n");

	for (i = 0; i < 40; i++)
	{
		printf("%d ", str->arr[i] = i + 1);
	}
	str->i = 1314;
	//释放空间

	free(str);
	str = NULL;
	return 0;
}



//第二种写法：
//将结构体整体使用malloc申请空间，
//因为数组名的本质是数组首元素的地址，
//我们可以继续使用malloc申请空间并且将malloc返回的起始地址赋予给数组名

#include<stdio.h>
#include<stdlib.h>
struct S
{
	int n;
	int* arr;
};


int main()
{
	struct S* pd = (struct S*)malloc(sizeof(struct S));
	if (pd == NULL)
	{
		perror("malloc");
		return 1;
	}

	//这里是第二次使用mallloc以达成让数组的大小可变
	int* tmp = (int*)malloc(20 * sizeof(int));
	if (tmp != NULL)//这里二次使用malloc，对其进行判断时需要将它的判断当作realloc的判断来写
	{
		pd->arr = tmp;
		tmp = NULL;
	}
	else
	{
		return 1;
	}

	//使用

	pd->n = 525;
	int i = 0;
	for (i = 0; i < 20; i++)
	{
		printf("%d ", pd->arr[i] = i + 1);
	}

	//调整 ---通过调整第二次的malloc，赋给结构体中的数组成员，从而改变数组大小
	tmp = (struct S*)realloc(pd->arr, 40 * sizeof(int));
	if (tmp != NULL)
	{
		pd->arr = tmp;//这里转换时需要将其数组给它
		tmp = NULL;
	}
	else
	{
		return 1;
	}

	//调整后使用

	pd->n = 520;
	
	for (i = 0; i < 40; i++)
	{
		printf("%d ", pd->arr[i]);
	}


	//释放时需要从小到大进行释放，大的释放时不需要置空,如果置空的话他会找不到小的，使得小的成为野指针
	free(tmp);
	free(pd);
	pd = NULL;

	return 0;
}

柔性数组的优势

第⼀个代码的好处是：⽅便内存释放
如果我们的代码是在⼀个给别⼈⽤的函数中，你在⾥⾯做了⼆次内存分配，并把整个结构体返回给⽤⼾。⽤⼾调⽤free可以释放结构体，但是⽤⼾并不知道这个结构体内的成员也需要free，所以你不能指望⽤⼾来发现这个事。所以，如果我们把结构体的内存以及其成员要的内存⼀次性分配好了，并返回给⽤⼾⼀个结构体指针，⽤⼾做⼀次free就可以把所有的内存也给释放掉。
第⼆个代码的好处是：这样有利于访问速度.
连续的内存有益于提⾼访问速度，也有益于减少内存碎⽚。（其实，我个⼈觉得也没多⾼了，反正你跑不了要⽤做偏移量的加法来寻址）实际上也没有提升多少访问速度，如果使用多次动态内存管理，就会导致内存碎⽚越来越多，从而造成空间浪费

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

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值