动态内存管理

阿明6

已于 2024-02-27 22:13:29 修改

阅读量509

点赞数 77

分类专栏：【C语言】文章标签： C语言

于 2023-10-01 21:15:29 首次发布

本文链接：https://blog.csdn.net/qq_72505850/article/details/133418367

版权

【C语言】专栏收录该内容

20 篇文章 1 订阅

订阅专栏

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

一、动态内存分配

对于内存分配，我们之前已经学过在栈空间开辟的局部变量

如

int main() 
{
	int var = 20;//局部变量在栈空间开辟四个字节
	char arr[10] = {0};//在栈空间开辟10个字节的连续空间
	return 0;
}

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

空间开辟的大小是固定的
数组在声明的时候，必须指定数组的长度，它所需要的内存在编译时分配

但是如果只是这样，有时候我们需要的空间大小在程序运行的时候才能知道，那数组的编译时开辟空间的方式就不能满足了。这时就可以采取动态内存开辟。

二、动态内存函数

1.malloc 和 free

malloc函数

void* malloc (size_t size);

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

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

#include<stdio.h>
#include<stdlib.h>
int main() 
{
	//申请一块空间，来存放5个整型
	int* p = (int*)malloc(sizeof(int)*5);//因为mallc原返回类型是void*,这里要进行强制类型转化
	if (p == NULL)
	{
		perror("malloc");//如果开辟失败会返回关于malloc的信息
		return 1;
	}
	return 0;
}

malloc 申请的空间是在内存堆区上申请的空间，而不是栈区上

如何使用malloc

#include<stdio.h>
#include<stdlib.h>
int main() 
{
	//申请一块空间，来存放5个整型
	int* p = (int*)malloc(sizeof(int)*5);//因为mallc原返回类型是void*,这里要进行强制类型转化
	if (p == NULL)
	{
		perror("malloc");//如果开辟失败会返回关于malloc的信息
		return 1;
	}
	//使用
	int i = 0;
	for (i = 0; i < 5;i++) 
	{
		*(p+i) = i;
	}
	//打印
	for (i = 0; i < 5; i++)
	{
		printf("%d ", * (p + i));
	}
	free(p);
	p = NULL;
	return 0;
}

对于上述malloc开辟的空间，上述使用完后，是使用free进行释放的

关于malloc函数的释放

1. free 释放，这是一种主动释放 2. 程序退出后，malloc申请的空间也会被操作系统回收的(被动)

我们在写代码的正常情况下，谁申请的空间，谁去释放; 万一自己没有释放，也要交代给别人，记得释放，避免内存泄漏。

free函数

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

void free (void* ptr);

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

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

注意: 使用 malloc 和 free 要引用头文件 stdlib.h

2.calloc

calloc也是用来开辟内存空间的

void* calloc (size_t num, size_t size);

我们发现calloc 与malloc 很像

就比如申请10个整型的空间

calloc(10,sizeof(int));

而上方的malloc

malloc(10*sizeof(int));

除了参数的区别，还有

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

calloc 函数的使用

//calloc内存函数的使用
#include<stdio.h>
#include<stdlib.h>
int main() 
{
	//动态分配5个整型空间
	int* p = (int *)calloc(5,sizeof(int));//动态分配并初始化空间，元素置零
	if (p == NULL)
	{
		perror("calloc");//如果动态分配失败，打印关于calloc的错误信息
	}
	int i = 0;
	//打印元素的值
	for (i = 0; i < 5;i++) 
	{
		printf("%d",*(p+i));
	}
	printf("\n");
	//元素赋值
	for (i = 0; i < 5;i++) 
	{
		*(p + i) = i;
		//二次打印
		printf("%d",*(p+i));
	}
	//使用free 函数进行空间释放，避免内存泄露
	free(p);
	p = NULL;//记得置为空
	return 0;
}

所以当我们需要动态分配内存空间并且需要初始化，使用calloc是一种很好的选择

3.realloc

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

对于动态内存函数realloc函数更加灵活

有时我们使用malloc和calloc函数进行动态内存分配的时候,我们发现所分配的空间已经固定下来，那木我们就会想会不会有一种可以调整动态内存大小的动态分配的内存函数呢？接下里就就是我们介绍的realloc内存函数，可以对动态内存空间进行重新调整大小。

ptr 是要调整的内存地址
size 调整之后新大小
返回值为调整之后的内存起始位置
这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到新的空间
realloc在调整内存空间的是存在两种情况
情况1

情况2

realloc函数的使用

//使用calloc 开辟空间，使用realloc调整空间
#include<stdio.h>
#include<stdlib.h>
int main() 
{
	//比如开辟5个整型空间
	int* p = (int*)calloc(5,sizeof(int));
	if (p == NULL)
	{
		perror("calloc");
		return 1;
	}
	int i = 0;
	for (i = 0; i < 5;i++)
	{
		*(p + i) = i;
	}
	//这里希望调整为10个整型的空间
	int* ptr = (int*)realloc(p,10*sizeof(int));
	if (ptr != NULL)
	{
		p = ptr;//如果开辟成功，p指向ptr
	}
	//给后续的5个空间赋值
	for (i = 5; i < 10; i++)
	{
		*(p + i) = i;
	}
	//打印
	for (i = 0; i < 10; i++)
	{
		printf("%d ",* (p + i));
	}
	free(p);
	p = NULL;
	return 0;
}

注意如果realloc的第一个参数为NULL 就等价于 malloc

realloc(NULL,10*sizeof(int)) == malloc(10*sizeof(int))

三、常见的动态内存错误

1.对NULL指针的解引操作

//对NULL指针的解引操作
int main()
{
	int* p = (int*)malloc(40);
	//没有对返回值判断，可能开辟内存失败，就使用了NULL指针，解引用
	*p = 20;
	free(p);
	return 0;
}

这里的改正应该是加上对空指针的判断语句

int main()
{
	int* p = (int*)malloc(40);
	if (p== NULL)
	{
		;
		//.....
	}
	*p = 20;
	free(p);
	return 0;
}

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

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)malloc(5 * sizeof(int));
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	int i = 0;
	for (i = 0; i <= 5;i++)//注意这里的等于号，越界访问了
	{
		*(p + i) = i;
	}
	free(p);
	p = NULL;
	return 0;
}

即使是动态内存函数开辟的空间，也是不能越界访问的

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

void test()
{
    int a = 10;
    int *p = &a;
    free(p);//这样是错误的
}

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

//使用free释放一块动态开辟内存的 一部分
void test() 
{
	int* p = (int*)malloc(100);
	p++;
	free(p);//注意这里是释放部分动态开辟的内存
}

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

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

    //...

	free(p);//重复释放是不对的
}

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

void test() 
{
	int* p = (int*)malloc(100);
	if (p != NULL) 
	{
		*p = 20;
	}
}
int main() 
{
	test();
	//..
	return 0;
}

忘记释放不再使用的动态开辟的空间会造成内存泄漏

动态开辟的空间一定要释放，并且正确释放

四、经典笔试题

分析下方代码

题1

//题1
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
void GetMemory(char* p)
{
	p = (char*)malloc(100);
}
void Test(void) 
{
	char* str = NULL;
	GetMemory(str);
	strcpy(str,"hello word");
	printf(str);
}
int main() 
{
	Test();
	return 0;
}

解析

代码改正

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
void GetMemory(char** p)
{
	*p = (char*)malloc(100);//*p找到外面的str
}
void Test(void)
{
	char* str = NULL;
	GetMemory(&str);//要想获取修改后的str,这里要把str的地址传过去
	strcpy(str, "hello word");//这时str指向存放100个字节的空间,然后把字符串拷贝过去
	printf(str);//打印
	//释放空间
	free(NULL);
	str = NULL;
}
int main()
{
	Test();
	return 0;
}

修改方法二

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
char* GetMemory()
{
	char *p = (char*)malloc(100);
	return p;//返回p
}
void Test(void)
{
	char* str = NULL;
	str = GetMemory();
	strcpy(str, "hello word");//这时str指向存放100个字节的空间,然后把字符串拷贝过去
	printf(str);//打印
	//释放空间
	free(NULL);
	str = NULL;
}
int main()
{
	Test();
	return 0;
}

题2

//题二
#include<stdio.h>
#include<stdlib.h>
char* GetMemory() 
{
	char p[] = "hello world";
	return p;
}
void Test() 
{
	char* str = NULL;
	str = GetMemory();
	printf(str);
}
int main() 
{
	Test();
	return 0;
}

解析

题3

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

解析

少了free(存在内存泄漏问题)

题4

//题4
void Test() 
{
	char* str = (char*)malloc(100);
	strcpy(str,"hello");
	free(str);
	if (str != NULL) 
	{
		strcpy(str,"word");
		printf(str);
	}
}
int main() 
{
	Test();
	return 0;
}

解析

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

在C/C++中，内存的开辟可以使用以下方法：

1. 静态内存分配：在编译时就分配好内存空间，例如定义全局变量和静态变量时所使用的内存就是静态内存。静态内存的特点是不需要程序员手动释放，但是分配的内存大小在编译时就已经确定，有一定的局限性。

2. 栈内存分配：在函数内部定义的局部变量所使用的内存就是栈内存，函数执行时自动分配内存，函数退出时自动释放内存。栈内存的特点是速度快，但分配的内存大小有限，可能会导致栈溢出。

3. 堆内存分配：使用动态内存分配函数（如malloc、new等）在堆中分配内存，程序员手动申请和释放内存。堆内存的特点是使用灵活，但需要程序员手动释放内存，否则会导致内存泄漏。

实际上普通的局部变量是在栈区分配空间的，栈区的特点是在上面创建的变量出了作用域就销毁。
但是被static修饰的变量存放在数据段（静态区），数据段的特点是在上面创建的变量，直到程序
结束才销毁
所以生命周期变长

六、柔性数组

柔性数组（Flexible Array）是一种特殊的数组类型，在定义数组时可以不指定其长度，而是通过程序运行时动态地分配数组空间

struct flex_array {
    size_t len;
    int data[]; // 柔性数组，未知大小的数组
};

其中，data就是柔性数组，它的长度可以在程序运行时动态调整，而len则记录了数组当前的长度。在使用柔性数组时，通常需要使用动态内存分配函数（如malloc、calloc等）来为其分配空间，同时也需要注意在使用完毕后及时释放内存，以避免内存泄漏等问题

1.柔性数组的特点

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

2.柔性数组的使用

#include<stdio.h>
#include<stdlib.h>
struct S 
{
	char c;
	int i;
	int arr[];
};
int main() 
{
	struct S* ps = (struct S*)malloc(sizeof(struct S)+20);
	if (ps == NULL) 
	{
		perror("malloc");
		return 1;
	}
	ps->c = 'w';
	ps->i = 100;
	int i = 0;
	for (i = 0; i < 5;i++) 
	{
		ps->arr[i] = i;
	}
	//打印
	for (i = 0; i < 5;i++)
	{
		printf("%d ",ps->arr[i]);
	}
	printf("%c %d",ps->c,ps->i);
	//当空间不够用就使用realloc 继续增加
	struct S* ptr = (struct S*)realloc(ps,sizeof(struct S*)+40);
	if (ptr == NULL)
	{
		perror("realloc");
		return 1;
	}
	free(ps);
	ps = NULL;
	return 0;
}

3.柔性数组的优势

方便内存释放：

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

有利于提高访问速度：

连续的内存有益于提高访问速度，也有益于减少内存碎片。

阿明6

关注

77
点赞
踩
69

收藏

觉得还不错? 一键收藏
78
评论
动态内存管理

有时我们使用malloc和calloc函数进行动态内存分配的时候,我们发现所分配的空间已经固定下来，那木我们就会想会不会有一种可以调整动态内存大小的动态分配的内存函数呢？所使用的内存就是栈内存，函数执行时自动分配内存，函数退出时自动释放内存。栈内存的特点是速度快，但分配的内存大小有限，可能会导致栈溢出。但是如果只是这样，有时候我们需要的空间大小在程序运行的时候才能知道，那数组的编译时开辟空间的方式就不能满足了。如果我们的代码是在一个给别人用的函数中，你在里面做了二次内存分配，并把整个结构体返回给。
复制链接

扫一扫