【c语言】动态内存管理

最新推荐文章于 2024-05-27 13:31:40 发布

CV工程师小林

最新推荐文章于 2024-05-27 13:31:40 发布

阅读量160

点赞数 1

分类专栏： C语言杂烩文章标签： c语言开发语言

本文链接：https://blog.csdn.net/waluolandao/article/details/130976493

版权

C语言杂烩专栏收录该内容

9 篇文章 0 订阅

订阅专栏

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

一、动态内存分配

对于以下变量的声明：

int val = 20; （在栈区上开辟四个字节）

char arr[10] = {0}; （在栈区上开辟10个字节的连续空间）

都是在栈区（静态申请的内存的存放地）上申请空间，申请的空间大小是固定不变的。而对于数组，在其声明时必须指定数组的长度，且所需要的内存在编译时才分配。

但对于空间申请的需求，未必是始终固定不变的。

例如，当我们需要空间来存储一些信息，而空间容纳不下，或空间正好填满，但后续无法继续容纳。

这说明，实际所需的空间大小往往在程序运行的时候才能得知，那么，空间大小不变的申请方式，例如数组的编译时开辟空间的方式，有时就无法满足实际需求了。

这时如果空间的大小是可变的、可修改的，也许就能满足实际需求了。

于是就有了“动态内存分配”，即在堆区（动态申请的内存的存放地）上申请空间。

二、动态内存函数

malloc

void* malloc(size_t size);
[小结]
1.功能：向内存（堆区）申请一块连续可用的空间，并返回指向这块空间的指针
2.头文件：<stdlib.h>
3.返回类型：void*
4.参数类型：size_t（unsigned int）
[ps]
1>若空间开辟成功，则返回一个指向开辟好的空间的指针。若开辟失败，则返回一个NULL指针。因此malloc的返回值一定要做检查。
2>因为返回值的类型是 void* ，即malloc函数并不知道开辟空间的类型，所以具体使用的时候需使用者自己来决定，即按需对返回类型做强制类型转换
3>若参数size为0，则malloc的行为是标准是未定义的，实际取决于编译器。
4>malloc是在堆区上申请空间，空间使用完后需要释放

free

void free (void* ptr);
[小结]
1.功能：释放动态申请的内存
2.头文件：<stdlib.h>
3.返回类型：void
4.参数类型：void*
[ps]
1>如果参数 ptr 指向的空间不是动态申请的，那free函数的行为是未定义的。
如果参数 ptr 是NULL指针，则函数什么事都不做。
2>释放内存后，动态申请的空间会被回收给内存，该空间无法将再使用
3>对动态申请的空间只能释放一次，不可重复释放
4>不可用于释放静态申请的空间

[ 例 ]

int main()
{
	//申请40个字节，用来存放10个整型
	int* p = (int*)malloc(40);

    //检验是否开辟成功
	if (p == NULL)                //创建失败则返回空指针
	{
		printf("%s\n", strerror(errno)); //探究错误类型，
		return 1;                        //且不继续执行
	}
 
	//存放1~10到开辟的动态空间中
	int i = 0;
	/*
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i + 1;
	}*/
 
	//打印malloc赋值前储存的值
	for (i = 0; i < 10; i++)
	{
		printf("%d\n", *(p + i));    //随机值
	}
 
	//释放申请的内存
	free(p);
	p = NULL;
    //free（）释放内存，将申请的空间回收给内存，使该空间无法再使用，但并不会将p置为空    
    //（即p的值并不改变），故后续使用p可能存在非法访问。主动置p为空，防止非法访问。

	return 0;
}

[补] 动态申请内存与一般静态申请内存的不同点在于，静态申请的内存是放在栈区的，而动态申请的内存是放在堆区的。栈区的特点是申请的内存不需要手动释放，一个变量的生命周期结束后系统会自动将其释放；而堆区需要手动释放，如果不手动释放，则有可能会造成内存泄漏等重大问题（内存泄漏是指，一个程序在运行时所占用的内存不断增大，不及时处理会导致计算机内存占用过多）。所以我们使用动态申请的内存结束后，一定要将其释放。

[注] free释放空间只对动态申请的空间起用，不可以手动释放静态申请的空间，且对动态申请的空间只能手动释放一次，不可重复释放。

calloc

void* calloc (size_t num, size_t size);
[小结]
1.功能：开辟num个大小为size的动态空间,并把空间的每个字节初始化为0
2.头文件：<stdlib.h>
3.返回类型：void*
4.参数类型：size_t的空间数量和空间大小
[ps]
1>calloc相对于malloc的区别只是，calloc会把空间的每个字节初始化为0。
2>malloc、calloc都是在堆区上申请空间,空间使用完后都要释放
3>malloc申请到的空间没有初始化，直接返回起始地址；
calloc申请空间后会将空间全部初始化为0，然后才返回起始地址

[ 例 ]

 int main()
{
	int*p = (int*)calloc(10, sizeof(int));
	if (NULL == p)
	{
		perror("calloc");
		return 1;
	}
 
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", *(p + i));    //全为0
	}

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

	return 0;
}

realloc

void* realloc(void* ptr, size_t size);
[小结]
1.功能：调整已申请的动态空间的大小
2.头文件：<stdlib.h>
3.返回类型：void*
4.参数类型：void* - 调整的内存地址，size_t - 调整后的大小
[ps]
realloc函数的意义，是让动态内存管理更加灵活。
有时过去申请的空间太小了，有时候申请的空间过大了，
这时为了合理地使用内存，就需要对动态空间的大小做灵活的调整。
realloc 函数就可以做到对动态申请内存的大小的灵活调整。

[ 例 ]

int main()
{
	int*p = (int*)malloc(5 * sizeof(int));
	if(NULL == p)
	{
		perror("malloc");
		return 1;
	}
 
	//使用
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		*(p + i) = 1;
	}
 
	//不够了，增加5个整型的空间
	int* ptr = (int*)realloc(p, 1000*sizeof(int));    //用新指针接收
	if (ptr != NULL)
	{
		p = ptr;
		ptr = NULL;
	}
 
	//继续使用空间
	for (i = 0; i < 10; i++)
	{
		printf("%d ", *(p + i));
	}

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

	return 0;
}

[补] 若原本的空间之后有足够的空间可用于扩容，则realloc会直接在原本的空间后面续上新的空间，并返回旧的起始地址。若原本的空间之后没有足够的空间用于扩容，则realloc会另找一个满足空间大小需求的新连续空间，从新空间的头位置开始，将旧空间的数据拷贝至新空间，并将旧空间释放，返回新空间的起始地址。

int main()
{
	
	int*p = (int*)realloc(NULL, 40);
  //如此书写，功能和malloc相同

	return 0;
}

三、常见的动态内存错误/误区

3.1 对NULL指针的解引用操作

int main()
{
	int* p = (int*)malloc(100);
	
//若malloc申请失败，则p就为NULL指针了，此时不可对p进行非法的解引用操作
//故每次申请后应对malloc的返回值进行判断：
//if (NULL == p)
//	{
//		perror("malloc fail");
//		return;
//	}

	int i = 0;
	for (i = 0; i < 20; i++)
	{
		*(p + i) = 0;
	}
    return 0;
}

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

int main()
{
	int*p = (int*)malloc(100);    //空间只能存放25个整型，而非100个
	if (p == NULL)
	{
		return 1;
	}

	int i = 0;
	for (i = 0; i < 100; i++)
	{
		//*(p + i) = 0;    //越界访问
		p[i] = 0;          //越界访问
	}

	free(p);
	p = NULL;

	return 0;
}

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

int main()
{
	int a = 10;    //整型变量存放在栈区
	int* p = &a;

	free(p);       //对堆区释放     //编译器报错
	p = NULL;

	return 0;
}

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

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

	free(p);    //此时p已经不指向起始位置
	p = NULL;

	return 0;
}

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

int main()
{
	int* p = (int*)malloc(100);
	if (p == NULL)
	{
		return 1;
	}

	free(p);
	p = NULL;    //没有这句，下面会报错
  
	free(p);     //已有上句，free（）不干事

	return 0;
}

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

void test()
{
	int* p = (int*)malloc(100);
	if (p == NULL)
	{
		return 1;
	}
	
	free(p);
	p = NULL;
}
int* test()
{
	int* p = (int*)malloc(100);
	if (p == NULL)
	{
		return 1;
	}
	
	return p;    //函数内部进行了malloc操作，返回了malloc开辟的空间的起始地址

int main()
}

{
	int*ptr = test();
	free(ptr);
	ptr = NULL;
	
	return 0;
}
//忘记释放不再使用的动态开辟的空间会造成内存泄漏。
//切记：动态开辟的空间一定要释放，且要正确释放。

//但就算开辟和释放成对出现，仍可能存在问题
void test()
{
	int* p = (int*)malloc(100);
	if (NULL == p)
	{
		return;
	}
	
	if (1)
		return;
	
	free(p);    //有可能没机会执行
	p = NULL;
}
int main()
{
	test();
	return 0;
}
//故，开辟和释放成对出现，且释放要执行成功

[ 补 ] 相关笔试题

1.动态空间的非法访问+内存泄露

//请问运行test函数会有什么样的结果？

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的临时拷贝，有自己独立的空间。
//  当GetMemory函数内部申请了空间后，地址放在p中，但str依然为空。
//  当函数返回之后，strcpy拷贝时就发生了非法访问内存。
//2.在GetMemory函数内部动态申请了内存，但没有释放，可能会发生内存泄露。

//修改：

//法1 二级指针传参
void GetMemory(char** p)     //二级指针存的是一级指针的地址
{
	*p = (char*)malloc(100);
  //判断是否开辟成功、p是否为空等小细节，此处略
}

void Test(void)
{
	char* str = NULL;
	GetMemory(&str);    //传址调用
	strcpy(str, "hello world");
	printf(str);
	free(str);         //释放
	str = NULL;
}
int main()
{
	Test();
	return 0;
}

//法2 设定GetMemory的返回类型为char*
char* GetMemory()
{
	char* p = (char*)malloc(100);
	return p;
}

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

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

//[补]
int main()
{
	char* p = "hehe\n";
	
	printf("hehe\n");
	printf(p);//与上一句等价
	return 0;
}

2.返回栈空间地址的问题

//请问运行test函数会有什么样的结果？

char* GetMemory(void)
{
	char p[]="hello world";    //在栈上开辟空间
	return p;                  //返回“h”的地址后，空间销毁
}
void Test(void)
{
	char* str = NULL;
	str = GetMemory();         //赋值“h”的地址，但空间被销毁，访问空间则发生非法访问
	printf(str);               //打印出随机值
}
int main()
{
	test();
	return 0;
}

//修改：
char* GetMemory(void)
{
  //char* p[]="hello world"
	static char p[]="hello world";    //将空间开辟至静态区
	return p;
}
void Test(void)
{
	char* str = NULL;
	str = GetMemory();
	printf(str);            //hello world
}
int main()
{
	test();
	return 0;
}

//其他类似的例子：
int* test()
{
	int a = 10;            //脱离函数后，a被销毁
	return &a;
}
int main()
{
	int* p = test();
	printf("%d\n", *p);    //可能是10，可能是随机值
	return 0;
}

// - - - - - -

int* test()
{
	int a = 10;
	return &a;
}
int main()
{
	int* p = test();
	printf("hehe\n");      //printf函数调用时，栈帧可能覆盖掉a的空间
	printf("%d\n", *p);    //VS2019下打印出：5（故生成随机值）
	
	return 0;
}

3.内存泄露

//请问运行test函数会有什么样的结果？


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.释放后未置空

//请问运行test函数会有什么样的结果？

void Test(void)
{
	char* str= (char*)malloc(100);
	strcpy(str, "hello");
	free(str);                   //释放后，str为野指针。故应添加：str=NULL;
	if(str!=NULL)
	{
		strcpy(str, "world");    //非法访问
		printf(str);
	}
}
int main()
{
	Test();
	return 0;
}

[ 补 ] C/C++程序的内存开辟

1. 栈区（stack）：在函数执行时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。

2. 堆区（heap）：一般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收。分配方式类似于链表。

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

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

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

[ 补 ] 柔性数组

C99标准中，结构体中的最后一个元素允许是未知大小的数组，这就叫做『柔性数组』成员。

//如：
struct s
{
	int i;
	int a[0];     //柔性数组成员 数组的大小是未知的
    //int a[];    //上句在部分编译器中会报错无法编译，可以改成这句
};

//1> 结构中的柔性数组成员前面必须至少一个其他成员。
//2> sizeof 返回的这种结构大小不包括柔性数组的内存。
例：
 struct s
{
   int n;//4
   char a[];
};
int main()
{
	 printf("%d\n", sizeof(s));//4
}
 
//3> 包含柔性数组成员的结构用malloc()函数进行内存的动态分配，并且分配的内存应该大于结构的大小，
//   以适应柔性数组的预期大小。
例：
struct S
{
	int n;//4
	char arr[];
};
int main()
{
  //创建
	struct S* ps = (struct S*)malloc(sizeof(struct S) + 10 * sizeof(char));
  //赋值	
  ps->n = 100;
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		ps->arr[i] = 'Q';
	}
	//打印
	for (i = 0; i < 10; i++)
	{
		printf("%c ", ps->arr[i]);
	}
  //增容
	struct S* ptr = (struct S*)realloc(ps, sizeof(struct S)+20*sizeof(char));
	if (ptr != NULL)
	{
		ps = ptr;
	}
	else
	{
		perror("realloc");
		return 1;
	}
  //使用
  //...
  //释放
	free(ps);
	ps = NULL;
}

//类比：
struct S
{
	int n;
	char* arr;//·
};

int main()
{
	struct S* ps = (struct S*)malloc(sizeof(struct S));
	if (ps == NULL)
	{
		perror("malloc");
		return 1;
	}
	ps->n = 100;
	ps->arr = (char*)malloc(sizeof(char)*10);
	if (ps->arr == NULL)
	{
		perror("malloc->arr");
		return 1;
	}
	//使用
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		ps->arr[i] = 'Q';
	}
	//增加
	char* ptr = (char*)realloc(ps->arr, 20*sizeof(char));
	if (ptr != NULL)
	{
		ps->arr = ptr;
	}
	else
	{
		perror("realloc->ptr");
		return 1;
	}
	//使用
  //...
	//释放
	free(ps->arr);
	ps->arr = NULL;
	free(ps);
	ps = NULL;

	return 0;
}

[小结]
1.柔性数组，malloc一次、free一次，过程不易出错，且空间连续，利于减少内存碎片，访问效率高。
2.普通指针，malloc两次、free两次，过程易出错，且空间不连续，可能出现内存碎片，访问效率低。

CV工程师小林

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
【c语言】动态内存管理

实际所需的空间大小往往在程序运行的时候才能得知，那么，空间大小不变的申请方式，，有时就无法满足实际需求了。这时如果空间的大小是可变的、可修改的，也许就能满足实际需求了。于是就有了“动态内存分配”，即在堆区（动态申请的内存的存放地）上申请空间。
复制链接

扫一扫