C语言：动态内存管理

已于 2024-09-17 20:57:58 修改
阅读量346 收藏
点赞数 19
文章标签： c语言 经验分享 笔记 开发语言
于 2024-09-17 20:40:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zm3rttqs9f/article/details/142302775
版权

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

现在我们已经学习了两种开辟内存空间的方式：

int a=0;//申请4个字节的空间
int arr[10]={0};//申请40个字节的连续空间

我们发现这样开辟的空间大小是固定的，而且数组一开始就要确定大小，并且不能修改。但是对于空间的需求，不仅仅是上述的情况。有时候我们需要的空间大小在程序运行的时候才能知道，那数组的编译时开辟空间的方式式就不能满足了。 所以，C语言引入了动态内存开辟，让程序员自己可以申请和释放空间，这样就比较灵活了。

二.动态内存开辟函数和释放函数

以下这些函数中申请的空间都是向堆区申请的，并且动态内存开辟函数和释放函数都包含在头文件：#include<stdlib.h>

1.malloc函数

C语言提供了一个动态内存开辟的函数： 

void* malloc (size_t size);
  • 返回类型：void* 因为在malloc函数是不知道我们想要申请什么类型的空间，在使用时我们会利用强制类型转换得到我们想要的返回类型。
  • size_t:参数类型。
  • size:申请空间的大小，单位是字节。 

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

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

使用： 

开辟一个空间，打印1-10的数字

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* ptr = (int*)malloc(40);
	if (ptr == NULL)//开辟失败，进行检查
	{
		perror("malloc");//打印错误信息
		return 1;//异常返回
	}
	for (int i = 0; i < 10; i++)
	{
		*(ptr + i) = i + 1;
		printf("%d ", *(ptr + i));
	}
	return 0;
}

2.free函数

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

 void free (void* ptr);

注意：free函数是专门用来释放动态开辟的内存。 

返回类型：void

参数类型：void*

p:传入的地址

注意：传入的地址为动态内存空间的起始地址

注：

  • 如果参数 ptr 指向的空间不是动态开辟的，那free函数的行为是未定义的。
  • 如果参数 ptr 是NULL指针，则函数什么事都不做。 
  • 当我们将p指向的空间释放后，要将p置空，防止p成为野指针。

使用： 

在上一个代码中我们并没有用free函数来释放上个代码的内存空间，这样会导致内存泄漏，所以我们要用free函数去释放内存空间。

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* ptr = (int*)malloc(40);
	if (ptr == NULL)//开辟失败，进行检查
	{
		perror("malloc");//打印错误信息
		return 1;//异常返回
	}
	for (int i = 0; i < 10; i++)
	{
		*(ptr + i) = i + 1;
		printf("%d ", *(ptr + i));
	}
	free(ptr);
	ptr = NULL;
	return 0;
}

这样才是我们的完整代码。

3.calloc函数

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

void* calloc (size_t num, size_t size);

返回类型：void*

参数类型：size_t

num:开辟空间的个数。

size:一个开辟空间的大小。

作用： 

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

使用：

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* ptr = (int*)calloc(10,sizeof(int));
	if (ptr == NULL)//开辟失败，进行检查
	{
		perror("malloc");//打印错误信息
		return 1;//异常返回
	}
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", *(ptr + i));
	}
	free(ptr);
	ptr = NULL;
	return 0;
}

我们发现它的确把空间的每个字节都初始化为0了。

4.realloc函数

 C语言还提供了一个函数叫realloc，realloc函数的出现让动态内存管理更加灵活。

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

返回类型：void*

参数类型：void*   size_t

ptr:是要调整的内存地址 

size: 调整之后新大小

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

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

作用： 

  • realloc函数的出现让动态内存管理更加灵活。
  • 有时会我们发现过去申请的空间太小了，有时候我们又会觉得申请的空间过大了，那为了合理的使用内存，我们一定会对内存的大小做灵活的调整。那realloc函数就可以做到对动态开辟内存大小的调整。

调整情况： 

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

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

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

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

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

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

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

当是情况2 的时候，原有空间之后没有足够多的空间时，扩展的方法是：在堆空间上另找⼀个合适大小的连续空间来使用。这样函数返回的是一个新的内存地址。

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

使用： 

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* ptr = (int*)malloc(20);
	if (ptr == NULL)
	{
		perror("malloc");
		return 1;
	}
	for (int i = 0; i < 5; i++)
	{
		*(ptr + i) = i + 1;
		printf("%d ", *(ptr + i));
	}
	printf("\n");
	int* p = (int*)realloc(ptr, 40);
	if (p == NULL)
	{
		perror("realloc");
		return 1;
	}
	ptr = p;
	for (int i = 0; i < 10; i++)
	{
		*(ptr + i) = i + 1;
		printf("%d ", *(ptr + i));
	}
	free(ptr);
	ptr = NULL;
	return 0;
}

三.常见的动态内存的错误

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

void test()
 {
 int *p = (int *)malloc(INT_MAX/4);
 *p = 20;//如果p的值是NULL，就会有问题
 free(p);
 }

我们发现，这段代码并没有对其判断是否为空，和最后的置空。

修改：

void test()
{
	int* p = (int*)malloc(INT_MAX / 4);
	if(p!=NULL)
	*p = 20;//如果p的值是NULL，就会有问题
	free(p);
	p = NULL;
}

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

我们发现这段代码开辟的内存空间其实为10，而我们要访问的空间却达到了11个，这会导致越界访问。修改其实也很简单只需要让他访问10就可以了。

修改：

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);//ok
}

 在前面我们了解了free函数的使用，我们知道free函数是用来释放动态内存空间的，如果空间不是动态开辟的，那free函数的行为是未定义的。

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

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

根据对free函数的了解我们知道。free函数中的参数是动态内存的起始地址，如果不是将会导致内存泄漏。

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

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

如果我们这样写在我们运行代码的时候我们会发现，程序会崩溃

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

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

对于这种未进行空间释放的方式，会导致内存泄漏。

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

题目1：

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

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

我们会发现我们什么都没有输出

这是因为GetMemory函数使用时，用的是传值调用，p虽然申请到了空间，但是却是一段独立的空间，对str的值并没有影响，所以str依然等于NULL，所以什么都没打印。如果我们想要打印值其实我们只需改成传址调用即可。

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
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(void)
{
 char p[] = "hello world";
 return p;
}
void Test(void)
{
 char *str = NULL;
 str = GetMemory();
 printf(str);
}

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

我们发现他会打印一些随机值，这是为什么呢？

这是因为p是在栈区开辟的空间，当函数返回后，空间会被销毁，当此时我们已经将p的地址传给了str，这样就会导致str变成野指针，虽然能找到那片空间，但我们无权访问，所以就会打印随机值。那么如何避免这样呢，我们可以跟上个代码一样用动态内存。 

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
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;
}

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

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

这段代码本身运行起来我们发现没有任何问题

然而这段代码的问题其实就是会发生内存泄漏，我们要将空间释放，并置空。

#include<stdio.h>
#include<string.h>
#include<stdlib.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：

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

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

这段代码我们运行起来虽然结果正确，但还是有问题的？

1.根据上面的了解其中一个问题就是在释放完空间后我们并没有置空。

2.空间已经被我们释放了，但是我们仍然想向里面存入world，这肯定是不行的，但是结果却是我们成功打印了world,这是因为该内存空间并没有被覆盖，当然这个问题其实也很好解决，其实就是我们将他置空就可以了。

五.柔性数组

也许你从来没有听说过柔性数组这个概念，但是它确实是存在的。C99 中，结构中的最后一个元素允许是未知大小的数组，这就叫做『柔性数组』成员。

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

有些编译器会报错无法编译可以改成： 

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

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

2.柔性数组的使用

使用柔性数组打印0-100的数字

对于柔性数组的内存开辟，我们只需要在求出的结构体大小的后面加上我们想要赋给柔性数组的大小即可。

代码1：

#include <stdio.h>
#include <stdlib.h>
typedef struct st_type
{
	int i;
	int a[0];//柔性数组成员
}type_a;
int main()
{
	int i = 0;
	type_a* p = (type_a*)malloc(sizeof(type_a) + 100 * sizeof(int));
	//业务处理
	if (p != NULL)
	{
		p->i = 100;
		for (i = 0; i < 100; i++)
		{
			p->a[i] = i;
			printf("%d ", p->a[i]);
		}
	}
	free(p);
	p = NULL;
	return 0;
}

3.柔性数组的优势

 对于上面的代码其实我们也可以用下面这种方式实现

代码2：

#include <stdio.h>
#include <stdlib.h>
typedef struct st_type
{
	int i;
	int* a;
}type_a;
int main()
{
	type_a* p = (type_a*)malloc(sizeof(type_a));
	if (p != NULL)
	{
		p->i = 100;
		p->a = (int*)malloc(p->i * sizeof(int));
	}

	//业务处理
	if (p->a != NULL)
	{
		for (int i = 0; i < 100; i++)
		{
			p->a[i] = i;
			printf("%d ", p->a[i]);
		}
	}

	//释放空间
	free(p->a);
	p->a = NULL;
	free(p);
	p = NULL;
	return 0;
}

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

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

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

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

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

好了今天分享就到这里了，我们下一篇见！ 

星迹日
关注
C语言:动态内存管理与开辟
m0_57781912的博客
04-05 914
C语言动态内存学习笔记
C语言：动态分配内存
立于皓月之边，不弱星光之势
12-07 2905
2022-12-07（动态分配内存）
C语言:动态内存分配+经典面试题
须知少日拏云志，曾许人间第一流。
05-07 1694
通常，我们在栈空间开辟的内存都是固定的，这是十分不方便使用的。为了更加灵活的分配和使用内存，我们要学习C语言中一些常用的与内存分配相关联的函数。顺便，我们会补充数组中柔性数组的知识。
c语言十七：动态内存申请
qq_33808440的博客
03-14 6395
动态内存申请一 动态内存申请二 静态分配内存和动态分配内存2.1 静态分配内存2.2 动态分配内存三 动态内存申请的相关函数3.1 分配内存空间函数 malloc3.2 free函数 （释放内存函数）3.3 案例一：从堆区申请一个int类型的空间3.4 案例二：从堆区申请一个数组，数组的大小由用户决定3.5 calloc函数3.5 realloc函数（重新申请内存空间）四 内存泄漏 一 动态内存申请 数组的长度是预先定义好的，在整个程序中固定不变； 但在实际应用中，往往有这种情况，所需要的内存空间取决
C/C++：动态内存管理
weixin_43908419的博客
03-04 2768
本文对C/C++动态内存管理进行了详解。第一章首先介绍了C/C++程序的内存分布情况，第二章介绍了C/C++动态内存管理相关的操作符和函数，最后一章介绍了内存泄漏。
C语言之动态内存管理
一只小卷毛的博客
11-07 976
动态内存管理（含四个关于动态内存开辟的函数以及柔性数组）
c语言篇（动态内存管理）
小马同学的博客
12-10 5060
动态内存管理，很重要的一篇文章，看完这篇让你深入理解动态内存的设置，和避免开辟的时候出现的一些问题！！！！
【C语言】深度解析：动态内存管理的机制与实践
大一在读，博客主要分享C/C++方向相关的内容，欢迎关注我的博主，希望可以跟各位大佬深入学习！
05-13 2596
本篇将深度解析:动态内存管理的机制。为了更加灵活分配内存中的空间，库中为了我们提供了一些的函数，去动态开辟和释放堆上的空间。
探索C语言的内存魔法：动态内存管理解析
Bettysweetyaaa的博客
02-10 3107
在C语言中，动态内存管理是一种非常强大的机制，能够让程序员更灵活地使用内存。与静态内存分配（如全局变量）相比，动态内存分配允许程序在运行时根据需要分配或释放内存。这种机制可以优化内存使用，减少内存浪费，并允许程序处理变长数据。 C语言提供了三个函数来实现动态内存分配：malloc、calloc和realloc。这些函数允许程序员动态地分配内存，并在不再需要时释放它。当程序需要处理变长的数据类型（如字符串、链表）时，动态内存分配是必不可少的。 但是，动态内存管理也存在一些问题。如果程序员不小心泄露内存或释
C语言内存管理：静态与动态分配的较量
07-28
### C语言内存管理：静态与动态分配的较量 #### C语言简介 C语言是一种通用的编程语言，由丹尼斯·里奇（Dennis Ritchie）在20世纪70年代早期于美国电话电报公司（AT&T）的贝尔实验室开发。C语言以其高效性、灵活...
MemoryManager:用C语言编写的内存管理模拟
04-02
用C语言编写的内存管理模拟。该项目将以我们选择的语言编写，我想我会挑战自己！ 内存管理器程序-自述文件@作者：Kerri McMahon 欢迎来到我的内存管理模拟程序。 一些简短的注意事项： -使用和运行程序： -Open ...
C语言内存管理：深入剖析内存泄漏及其防治策略
07-28
### C语言内存管理：深入剖析内存泄漏及其防治策略 #### C语言概述 C语言作为一种通用且高效的编程语言，自20世纪70年代由丹尼斯·里奇在贝尔实验室开发以来，便因其强大的特性和广泛的适用性而在软件开发领域占据...
09-排序1 排序（C）
2301_80474443的博客
09-13 923
这一节，测试各类排序算法的运行速度（没有基数排序（桶）其实在实际学习中，还是有意义的
高级c语言（六）
最新发布
m0_63127040的博客
09-15 1126
​for(;;sleep(1);sec++;​字符就是符号或图案，但在计算机中以整数形式存在，当需要显示时，会根据ASCII表中的对应关系显示出相应的符号或图案。在C语言中使用char类型的变量存储字符的ASCII码值，也就是使用整数进行模拟字符，标准的ASCII码表的范围是：0~127，共128个字符，其他的语种，使用-128~-1进行设计字符编码，比如中文的汉字，使用的是2~3字节存储一个汉字。
C和指针：数组(一维数组，多维数组，指针数组)
暮色年华的博客
09-13 850
char const *string这样的类型声明时，string是一个指向字符的指针，这个字符是指向的内容是不可修改的。上面两个声明等价，数组当作参数传入函数本质是传入指针，但是它传递的只是数组第一个元素的指针，但是这种方法无法让函数知道数组的确切长度，所以需要把数组长度显示传入函数中。d是一个包含3个元素的数组，每个元素都是包含6个元素的数组，6个元素中的每一个又都是包含10个整型元素的数组。c是个一维数组的一维数组。一维数组名的值是一个指针常量，类型是指向元素类型的指针，指向数组的第1个元素。
智能工厂的程序设计 之 程序框架：三种API（用户U、客户C、服务S）的三个分层
ChuanfangChen的博客
09-12 1459
三种API (用户、客户、服务) 的三个层：隔离层（应用DIY的缺省点）-要“分离”，隐藏层（客户定制的缺失点）- 有“掩体” 和 防腐层（服务自动部署的缺陷点）-被“覆盖”。三者分别指向“程序”的所有三类“变点”（切点、埋点和插点）： 横切点（实践常识的关注点 -预设路径），竖埋点（ 科学方法的兴趣点--预埋管道）和 斜插点（理论偏序集的扩展点--预留位置）；这三类“程序”“变点”分别需要：一个领域驱动设计、一个微服务架构和 一个 灵活的模块化框架。
全国计算机二级考试C语言篇4——选择题
2302_77517102的博客
09-09 808
逗号运算符的优先级是所有运算符中级别最低的，逗号运算符保证左边的子表达式运算结束后才进行右边的子表达式的运算。也就是说，逗号运算符是一个序列点，其左边所有副作用都结束后，才对其右边的子表达式进行运算，并以最右边表达式值作为整个逗号表达式的值。本条语句首先执行赋值运算d=1，由于b并未定义，故编译不通过，提示没有定义 标识符b、c、d，故该项项错。2.赋值运算结合性为由右向左结合，赋值运算符左值为变量，右值为变量或常量，且左右两边数据类型相同才能实现赋值。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值