5.动态内存管理

最新推荐文章于 2023-06-13 01:16:07 发布
最新推荐文章于 2023-06-13 01:16:07 发布
阅读量72 收藏
点赞数
分类专栏： C进阶 文章标签： c语言 c++ 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46585133/article/details/120791038
版权
本文详细介绍了动态内存分配的必要性，重点讲解了malloc、calloc、realloc三种内存管理函数的用法，涵盖了内存错误处理和经典面试题。讨论了C/C++程序中栈、堆、静态区的区别，以及柔性数组的特性。
摘要由CSDN通过智能技术生成

1. 为什么存在动态内存分配

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

	return 0;
}

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

  1. 空间开辟大小是固定的。

  2. 数组在申明的时候，必须指定数组的长度，它所需要的内存在编译时分配。

但是对于空间的需求，不仅仅是上述的情况。有时候我们需要的空间大小在程序运行的时候才能知道，那数组的编

译时开辟空间的方式就不能满足了。 这时候就只能试试动态存开辟了。

2.动态内存函数的介绍

2.1 malloc和free

void* malloc (size_t size);

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

如果开辟成功，则返回一个指向开辟好空间的指针。

如果开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做检查。

返回值的类型是 void* ，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定。

如果参数 size 为0，malloc的行为是标准是未定义的，取决于编译器。

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

void free (void* ptr);

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

如果参数 ptr 指向的空间不是动态开辟的，那free函数的行为是未定义的。

如果参数 ptr 是NULL指针，则函数什么事都不做。

#include<stdlib.h>

int main()
{
	//int arr[10] = { 0 };

	//申请空间
	int* p = (int*)malloc(40);
	
	//检查是否开辟成功
	if (p == NULL)
	{
		return -1;
	}

	//开辟成功:使用
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i;
	}

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

	free(NULL);//OK

	return 0;
}

malloc函数只负责在堆区申请空间，并且返回起始地址，不初始化内存空间

2.2 calloc

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

void* calloc (size_t num, size_t size);

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

#include<string.h>
#include<errno.h>

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

	//检查是否开辟成功
	if (p == NULL)
	{
		printf("%s\n", strerror(errno));
		return -1;
	}

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

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

	return 0;
}

2.3 realloc

realloc函数的出现让动态内存管理更加灵活。

有时会我们发现过去申请的空间太小了，有时候我们又会觉得申请的空间过大了，那为了合理的时候内存，

我们一定会对内存的大小做灵活的调整。那 realloc 函数就可以做到对动态开辟内存大小的调整。 函数原型

如下：

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

ptr 是要调整的内存地址

size 调整之后新大小

返回值为调整之后的内存起始位置。

这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到 新 的空间。

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

情况1：原有空间之后有足够大的空间

情况2：原有空间之后没有足够大的空间

当是情况1 的时候，要扩展内存就直接原有内存之后直接追加空间，原来空间的数据不发生变化。 情况****2 当

是情况2 的时候，原有空间之后没有足够多的空间时，扩展的方法是：在堆空间上另找一个合适大小的连续空间来

使用。这样函数返回的是一个新的内存地址。

#include<string.h>
#include<errno.h>

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

	//检查是否开辟成功
	if (p == NULL)
	{
		printf("%s\n", strerror(errno));
		return -1;
	}

	//开辟成功:使用
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i;
	}

	//空间不够，增加至20个int
	int* ptr = (int*) realloc(p, 20 * sizeof(int));

	//检查是否增容成功
	if (ptr == NULL)
	{
		printf("%s\n", strerror(errno));
		return -1;
	}
	else
	{
		p = ptr;
	}

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

	//打印
	for (i = 0; i < 20; i++)
	{
		printf("%d ", *(p + i));
	}

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

	return 0;
}

3.常见的动态内存错误

3.1 对NULL指针的解引用操作

int main()
{
	int* p = (int*)malloc(20);
	if (p == NULL)
		return -1;

	*p = 0;//直接这样写有风险！

	return 0;
}

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

int main()
{
	int* p = (int*)malloc(200);
	if (p == NULL)
		return -1;

	//使用
	int i = 0;
	for (i = 0; i < 80; i++)
	{
		*(p + i) = i;
	}

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

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

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

	free(p);
	p = NULL;//err

	return 0;
}

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

int main()
{
	int* p = (int*)malloc(10 * sizeof(int));
	if (p == NULL)
		return -1;
	
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*p++ = i;
	}

	free(p);
	p = NULL;//err

	return 0;
}

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

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

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

//在堆区上申请的空间，有两种回收方式	1.free	2.程序退出
int main()
{
	int* p = (int*)malloc(100);
	if (p == NULL)
		return -1;

	//忘记释放
	getchar();

	return 0;
}

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

局部变量的指针不能做返回值，因为子函数的空间此时已经被释放了

4.几个经典的笔试题

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

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

int main()
{
	Test();

	return 0;
}
///程序运行崩溃！而且存在内存泄露！没有释放开辟的空间
///1.str传参给p时候为值传递，p是str的零时拷贝，当malloc开辟的空间的起始地址放在p中的时候，不会影响str，str依然为NULL；
///2.当str为NULL，strcpy想吧hello，world拷贝到str指向的空间时发生程序崩溃，因为NULL指针指向的空间不能直接访问。

//改版1
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;
}

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

//改版2
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 main()
{
	Test();
	return 0;
}

int main()
{
	const char* p = "hello,world!";
	printf("hello,world!\n");
	printf("%s\n",p);
	printf(p);

	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;
}
//程序运行打印随机值：返回栈空间的地址的问题 

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;
}
//没有释放空间，内存泄露

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

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

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

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

  1. 栈区（stack）：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些

存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有

限。 栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。

  1. 堆区（heap）：一般由程序员分配释放，

若程序员不释放，程序结束时可能由OS回收 。分配方式类似于链表。

  1. 数据段（静态区）（static）存放全局变量、静态数据。程序结束后由系统释放。

  2. 代码段：存放函数体（类成员函数和全局函数）的二进制代码。

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

6.柔性数组

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


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

柔性数组的特点：

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

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

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

柔性数组的预期大小。

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

#include<string.h>
#include<errno.h>
int main()
{
	//printf("%d\n", sizeof(struct st_type));

	//包含柔性数组成员的结构使用要配合malloc这样的动态内存分配函数使用
	
	//struct st_type st;//err

	struct st_type* ps=(struct st_type*)malloc(sizeof(struct st_type) + 10*sizeof(int));
	if (ps == NULL)
	{
		printf("%s\n", strerror(errno));
		return -1;
	}
	//开辟成功，使用
	ps->i = 100;
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		ps->a[i] = i;
	}

	//a数组空间不够了，调整为20个整型数据
	struct st_type* ptr = (struct st_type*)realloc(ps , sizeof(struct st_type)+20*sizeof(int));
	if (ptr == NULL)
	{
		printf("扩展失败\n");
		return -1;
	}
	else
	{
		ps = ptr;
	}
	//扩展成功，使用
	//..........

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

	return 0;
}

struct st_type
{
	int i;//4
	int* a;//4
};

int main()
{
	struct st_type* ps = (struct st_type*)malloc(sizeof(struct st_type));

	ps->i = 100;
	ps->a = (int*)malloc(10*sizeof(int));
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		ps->a[i] = i;
	}
	for (i = 0; i < 10; i++)
	{
		printf("%d ", ps->a[i]);
	}
	//a指向的空间不够了，希望可以调整大小
	int* ptr = (int*)realloc(ps->a, 20*sizeof(int));
	if (ptr == NULL)
	{
		printf("扩容失败\n");
		return -1;
	}
	else
	{
		ps->a = ptr;
	}
	//使用
	//..
	
	//释放
	free(ps->a);
	ps->a = NULL;
	free(ps);
	ps = NULL;

	return 0;
}

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

**第一个好处是：**方便内存释放

如果我们的代码是在一个给别人用的函数中，你在里面做了二次内存分配，并把整个结构体返回给用户。用

户调用free可以释放结构体，但是用户并不知道这个结构体内的成员也需要free，所以你不能指望用户来发

现这个事。所以，如果我们把结构体的内存以及其成员要的内存一次性分配好了，并返回给用户一个结构体

指针，用户做一次free就可以把所有的内存也给释放掉。

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

连续的内存有益于提高访问速度，也有益于减少内存碎片。（其实，我个人觉得也没多高了，反正你跑不了

要用做偏移量的加法来寻址）。

或者zc
关注
专栏目录
深入详解C/C++动态内存管理
dvlinker的技术专栏
07-19 1万+
本文详细讲述了C/C++动态内存管理方面的内容，并具体阐述了几类常见的动态内存异常，以供大家借鉴或参考！
C语言中 free链表节点时程序崩溃的原因
ctz6d1p的博客
02-15 1598
C语言中 free链表节点时程序崩溃的原因 CRT detected that the application wrote to memory after end of heap buffer
c语言基础总结10动态内存分配
weixin_47641376的博客
07-28 323
为什么存在动态内存分配 我们已经掌握的内存开辟方式有： int val = 20;//在栈空间上开辟四个字节 char arr[10] = {0};//在栈空间上开辟10个字节的连续空间 但是上述的开辟空间的方式有两个特点： 空间开辟大小是固定的。 数组在申明的时候，必须指定数组的长度，它所需要的内存在编译时分配。 但是对于空间的需求，不仅仅是上述的情况。有时候我们需要的空间大小在程序运行的时候才能知道，那数组的编 译时开辟空间的方式就不能满足了。 这时候就只能试试动态内存开辟了（在堆区）
动态内存管理
zhanghangqian的博客
10-02 223
我们都知道平常的局部变量和函数形式参数实在栈区开辟的，但这个时候其内存所开辟空间的大小是固定的，而且所需要的内存在编译时分配，但很多时候我们所需要的空间大小在程序运行的时候才能知道，这个时候我们就只能试试动态内存开辟了。 1.动态内存函数的介绍 1.1 malloc和free void* malloc (size_t size); malloc函数的使用方法 这个函数向内存申请一块连续可用的空间，并返回指向这块空间的指针。 如果开辟成功，则返回一个指向开辟好空间的指针。 如果...
详解动态内存管理【malloc/calloc/realloc/free函数/柔性数组】【C语言/进阶/数据结构基础】
Man9o
03-28 2001
数据结构基础：动态内存管理函数（malloc/realloc/calloc）、经典笔试题、C/C++内存开辟的特点以及柔性数组
多次使用malloc分配内存可能会导致内存碎片的问题
最新发布
最后一个bug的博客
06-13 1984
如果后续释放了部分内存，那么这部分内存将会变成未使用的空间，但是它的大小可能不足以满足后续分配的内存需求。这样，堆中就会出现内存碎片，即许多小的未使用空间散落在堆中，无法满足大的内存分配请求。当不需要使用该块时，可以将其返回给内存池，而不是归还给操作系统，这样就可以重复利用这些小块内存，避免内存碎片问题。另一种策略是堆的整理（heap compaction），即在堆中移动已分配内存块的位置，使得所有未使用的空间都连续在一起。为了避免这个问题，可以采用一些策略来管理堆的空间，例如内存池和堆的整理等。
c语言动态内存开辟
Suinnn的博客
02-22 93
c语言动态内存开辟
连续动态内存管理模拟实现
05-15
动态内存管理允许程序在运行时请求和释放内存，提高了程序的灵活性。本项目关注的是连续动态内存管理，具体实现了一个基于“首次适应算法”的模拟器，用于64MB内存的分配与管理。 动态内存管理的核心目标是有效地...
操作系统专业课程设计连续动态分区内存管理模拟实现样本.doc
12-13
操作系统专业课程设计连续动态分区内存管理模拟实现样本 操作系统专业课程设计连续动态分区内存管理模拟实现样本是一种操作系统课程设计的模拟实现样本，旨在模拟实现操作系统的内存管理机制。该样本涵盖了操作系统...
C++指针与内存管理.doc
07-28
在C++编程中，内存管理和指针的使用是至关重要的，因为它们直接影响程序的稳定性和效率。本篇文章深入探讨了C++中指针与内存管理的相关概念和常见问题，旨在帮助程序员更好地理解和避免潜在的陷阱。 首先，文章介绍...
基于C语言的动态内存分配器.zip
06-15
这可能包括了设计思路、算法分析、性能评估以及如何编译和运行代码等信息，对于学习和理解动态内存管理机制非常有帮助。 从压缩包子文件的文件名来看，我们可以推测以下内容： 1. mdriver.c: 这可能是主驱动程序，...
Linux内核内存管理之如何解决内存碎片问题
m0_74282605的博客
02-07 420
以上就是解决内存碎片问题的详细介绍，内容较为全面，而且我也相信有相当的一些工具可能是我们日常工作可能会见到或用到的。这篇文章主要为大家详细介绍了解决内存碎片问题的方法，文中示例代码介绍的非常详细，图文详解容易学习，非常适合初学者入门。上分一块内存给你, 分出去了 好几块，内存紧张了， 释放这中间 就有一些内存用不了。一般需要大量数据节点的，都需要自己的缓冲池。也就是根据系统的负载开一块很大的内存出来,比如一个在线用户的信息 节点。就是有一些很小的空闲内存, 但是你申请的空间 可能就比他们要大，
内存碎片产生原因及解决方法
songtaoyulu的博客
11-22 1766
内存管理
c语言使用free释放指针报错,C语言中的free函数用法执行机制分析
weixin_34122532的博客
05-20 3516
free函数是C语言或者C++程序语言的常用函数，那么free函数有什么用途呢？free函数又怎么用呢？C语言中的free函数用法执行机制分析，一起来看看free内部的机制以及和delete的对比分析。与malloc()函数配对使用，释放malloc函数申请的动态内存。另外需要注意的是，对于free(p)这句语句，如果p是NULL指针，那么free对p无论操作多少次都不会出问题。如果p不是NULL...
浅析C语言之内存分配函数malloc()、realloc()、calloc()
海阔天空sky的博客
04-15 459
程序运行中动态分配内存，也就是从堆上分配内存，涉及到3个函数malloc()、realloc()、calloc()。 1、malloc() 函数原型： void * malloc( unsigned size); 功能：分配一块长度为size个字节的连续区域。不进行初始化。可使用menset()初始化。 返回值：该区域的首地址。可以将void*强制转换为需要的指针类型。 2、calloc
外部碎片和内部碎片
deeplan_1994的博客
10-22 981
 外部碎片，是由于大量信息由于先后写入、置换、删除而形成的空间碎片。  内部碎片，是由于存量信息容量与最小存储空间单位不完全相符而造成的空间碎片。还是沿用上面的例子，这次我们的6间仓库目前都是空置的，但是假设我们管理仓库的最小空间单位是间，今天运来了容量为2.5间仓库的货物，那也要占用我们1-3号3间仓库，尽管3号仓库还闲置着一半的空间，但是这半间仓库已经不能再利用了（因为是以间为最小单位么）；...
c语言free释放内存错误,为什么这段程序在加上free释放内存后会提示出错
weixin_34282558的博客
05-17 555
该楼层疑似违规已被系统折叠隐藏此楼查看此楼#include#includeint main(){int m = 0,n = 0;printf("请输入数组长度：");scanf("%d",&m);int* q = (int*)malloc(n*sizeof(int));if(q==NULL){printf("内存分配失败！");return 0;}for(;n{q[n]=1+n;}for...
C语言 free() 内存释放问题
TooSchoolForCool
05-01 7349
我们知道free(p)是释放掉p所指向的内存，那么是释放了多长的一段内存呢？我们的系统是如何知道要释放多少内存的呢？下面我来讲讲这个问题。 请看下面一段代码
关于free命令 内存的详细介绍以及如何手动释放内存
sweetfather的博客
09-29 7146
1 free命令   free命令可以显示当前系统未使用的和已使用的内存数目，还可以显示被内核使用的内存缓冲区。  total:去掉为硬件和操作系统保留的内存后剩余的内存总量。许多人奇怪自己的电脑安装了一共8G的内存，但是显示总共只有七点几G的，现在应该没什么疑惑了把，不管Linux还是Windows都会有部分内存是保留给硬件和操作系统的！ userd：当前已使用的内存总量。 free：空...
Qt动态内存管理：回收与资源释放
"Qt_动态内存管理QTQTQt" 在Qt框架中，动态内存管理是确保程序稳定性和资源有效利用的关键部分。Qt提供了多种方法来处理动态内存，包括使用`new`和`delete`操作符，以及一些特定的类和属性来帮助自动管理内存。以下...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值