C语言动态内存管理

于 2024-03-22 18:00:33 发布
阅读量1.3k 收藏 27
点赞数 41
分类专栏： C语言 文章标签： c语言 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_51904510/article/details/136941147
版权

对于内存， 比尔盖茨曾经失言：

640k ought to be enough for everybody

—— Bill Gates 1981 

目录

前言

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

二. malloc和free

1. malloc

1.1 函数介绍

1.2 代码分析

2. free

2.1 函数介绍

2.2 代码分析

三. calloc和realloc

1. calloc

1.1 函数介绍

1.2 代码示例

2. realloc

2.1 函数介绍

2.2 代码分析

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

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

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

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

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

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

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

五. 柔性数组

1. 柔性数组的特点：

2. 柔性数组的使用

3. 柔性数组的优势

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

写在最后

前言

在我们使用C语言编写程序时，我们会创建变量，数组等，系统会自动为它们开辟好相应大小的空间，但是，如果我们想随心所欲的开辟一块内存空间，并按照我们的需要指定这块空间的大小，那该怎么办呢？答案就是动态内存管理。

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

我们已经掌握的内存开辟方式有：

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

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

• 空间开辟大小是固定的。

• 数组在申明的时候，必须指定数组的长度，数组空间一旦确定了大小不能调整

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

C语言引入了动态内存开辟，让程序员自己可以申请和释放空间，就比较灵活了。

但是，方便的同时，也带来了隐患。

二. malloc和free

1. malloc

1.1 函数介绍

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

void* malloc (size_t size);

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

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

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

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

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

注意：使用动态内存相关的函数都需要包含头文件 <stdlib.h>

1.2 代码分析

假设我们需要开辟一块动态内存空间，用来存放4个整型数据，我们就可以这样写：

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

int main()
{
	int* pi = NULL;
	pi = malloc(4 * sizeof(int));
	//……
	return 0;
}

 我们创建了一个整型指针，并将其指向了malloc申请的16个字节的动态内存空间，现在，我们来观察程序的内存空间：

malloc创建了16个字节的动态内存空间

我们可以看到，malloc完成了我们给的任务，创建了16个字节的动态内存空间，但是，上面的代码写的万无一失了吗？

其实，我们在这里犯了一个大错误：就是对开辟的空间进行非空检查！​​​​​​​

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

int main()
{
	int* pi = NULL;
	pi = malloc(4 * sizeof(int));
	if (pi == NULL)
	{
		perror("malloc");
		return 1;
	}
	//……
	return 0;
}

那么，现在我们加入了检查，如果pi为空，我们就使用perror函数打印错误信息，并且程序返回1

如果你不是很了解perror函数，可以看看我的这一篇博客，希望能对你有所帮助：

C语言模拟实现部分库函数

 ​​​​​​​有人可能会说：现在的计算机内存那么大，怎么可能会出现申请内存失败的情况呢？

假如我们申请的并不是像现在这样的一小块空间，而是很大的一块空间呢？

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

int main()
{
	int* pi = NULL;
	pi = malloc(INT_MAX);
	if (pi == NULL)
	{
		perror("malloc");
		return 1;
	}
	//……
	return 0;
}

我们可以看到INT_MAX是一个非常大的数：

INT_MAX是一个非常大的数

 

而现在malloc就没有申请到这么大的一块空间，函数返回打印错误信息，且程序返回值为1：

malloc没有申请到空间

2. free

2.1 函数介绍

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

void free (void* ptr);

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

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

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

2.2 代码分析

现在，我们还是以1.2的代码为基础，假设此时我们使用完了这一段动态内存空间，要对其进行释放，我们写出来这一段代码，并对内存进行观察：

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

int main()
{
	int* pi = NULL;
	pi = calloc(4 * sizeof(int));
	if (pi == NULL)
	{
		perror("calloc");
		return 1;
	}
	//……(使用动态内存)
	free(pi);
	return 0;
}

free对申请的动态内存空间进行释放

我们可以看到，free函数也完成了任务，对申请的动态内存空间进行了释放。

那我们现在使用完了动态内存空间，也使用free函数进行释放了，这一段动态内存空间已经还给系统了，是不是也是万无一失的呢？

其实也不是，因为我们没有对pi这个指针进行置空

所以，我们可能会认为，free函数完成释放以后，pi指针也没用了，但是，free函数并没有完成对pi这个指针的置空，如果放任不管，可能会变成野指针

解决这个问题也很简单：手动置空即可

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

int main()
{
	int* pi = NULL;
	pi = malloc(4 * sizeof(int));
	if (pi == NULL)
	{
		perror("malloc");
		return 1;
	}
	//……(使用动态内存)
	free(pi);
	pi = NULL;
	return 0;
}

三. calloc和realloc

1. calloc

1.1 函数介绍

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

void* calloc (size_t num, size_t size);

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

• 与函数 malloc 的区别只在于 calloc 会在返回地址之前把申请的空间的每个字节初始化为全0。

所以如果我们对申请的内存空间的内容要求初始化，那么可以很方便的使用calloc函数来完成任务。

1.2 代码示例

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

int main()
{
	int* pi = NULL;
	pi = calloc(4, sizeof(int));
	if (pi == NULL)
	{
		perror("calloc");
		return 1;
	}
	//……(使用动态内存)
	free(pi);
	pi = NULL;
	return 0;
}

 

可以看到，calloc确实是在开辟动态内存空间的同时完成了初始化 

2. realloc

2.1 函数介绍

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

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

函数原型如下：

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

• ptr 是要调整的内存地址

• size 调整之后新大小

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

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

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

◦ 情况1：原有空间之后有足够大的空间，要扩展内存就直接原有内存之后直接追加空间，原来空间的数据不发生变化。

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

2.2 代码分析

我们还是以1.2的代码为基础，现在我们需要对动态内存空间进行调整，需要40个int类型的空间，于是，写出了这样的代码：

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

int main()
{
	int* pi = NULL;
	pi = calloc(4, sizeof(int));
	if (pi == NULL)
	{
		perror("calloc");
		return 1;
	}
	//……(使用动态内存)
	pi = realloc(pi, 40 * sizeof(int));
	if (pi == NULL)
	{
		perror("realloc");
		return 2;
	}
	//……(使用动态内存)
	free(pi);
	pi = NULL;
	return 0;
}

这个代码也看似没有问题，在完成动态内存空间的大小调整之后将起始地址再次返回，继续使用

但是，如果没有找到那么大的内存空间呢？

如果没有找到那么大的内存空间，realloc函数返回NULL，现在，你不仅没有申请到你想要的动态内存空间的大小，反而把你原来开辟的动态内存空间起始地址弄丢了，所以上面的代码是有问题的

应该怎么修改呢？可以再创建一个指针变量。

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

int main()
{
	int* pi = malloc(4 * sizeof(int));
	int* pi2 = realloc(pi, 40 * sizeof(int));
	if (pi2 == NULL)
	{
		perror("reallc");
		free(pi);
		pi = NULL;
		return 2;
	}
	else
	{
		pi = NULL;
	}
	free(pi2);
	pi2 = NULL;
	return 0;
}

现在，我们创建了新的指针变量pi2，在pi2获取到realloc函数返回值后对其进行非空检查，并进行相应操作，然后就可以使用调整后的动态内存空间了

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

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

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

 如果malloc申请动态内存失败，就会返回NULL，程序会报错

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

 使用时超过了开辟的动态内存空间的大小，造成了越界访问

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

void test()
{
    int a = 10;
    int *p = &a;
    free(p);//ok?
}

a不是动态内存开辟的空间，不能使用free释放

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

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

p不再是动态内存空间的起始地址

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

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

反复释放同一块动态内存空间，会报错

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

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

test函数创建了一块动态内存空间，却并没有释放该空间，并且没有返回该空间的起始地址，导致该动态内存空间无法释放，造成内存泄漏

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

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

五. 柔性数组

也许你从来没有听说过柔性数组（flexible array）这个概念，但是它确实是存在的。

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

如果你对结构体还不够了解，欢迎查看我的这一篇博客，希望能对你有所帮助：

C语言结构体详解

例如：

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

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

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

1. 柔性数组的特点：

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

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

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

例如：

#include <stdio.h>

typedef struct st_type
{
	int i;
	int a[0];//柔性数组成员
}type_a;
int main()
{
	printf("%zd\n", sizeof(type_a));//4
	return 0;
}

结果是4，证明了柔性数组的大小不包含柔性数组成员的大小

2. 柔性数组的使用

#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));
	//……
	p->i = 100;
	for (i = 0; i < 100; i++)
	{
		p->a[i] = i;
	}
	free(p);
	p = NULL;
	return 0;
}

通过malloc函数创建了结构体和100个整型变量的动态内存空间，实现了自定义数组成员数量，

这样柔性数组成员a，相当于获得了100个整型元素的连续空间。

3. 柔性数组的优势

上述的 type_a 结构也可以设计为下面的结构，也能完成同样的效果。

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

typedef struct st_type
{
	int i;
	int* p_a;
}type_a;

int main()
{
	type_a* p = (type_a*)malloc(sizeof(type_a));
	p->i = 100;
	p->p_a = (int*)malloc(p->i * sizeof(int));
	//业务处理
	for (int i = 0; i < 100; i++)
	{
		p->p_a[i] = i;
	}
	//释放空间
	free(p->p_a);
	p->p_a = NULL;
	free(p);
	p = NULL;
	return 0;
}

上面的前一段代码和这一段代码可以完成同样的功能，但是前一段代码的实现有两个好处：

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

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

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

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

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

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

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

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

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

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

写在最后

 动态内存管理虽然方便，却有不少的雷区，面对这些困难，我们也不应该害怕，计算机的学习就应当勇于探索

在我们使用动态内存空间时应当尽量做到“谁申请，谁释放”，确保不发生错误

如果你有好的建议与意见，欢迎在评论区友好交流，或者私信我，我们一起学习，一起进步。

感谢观看！ 

C的动态内存管理
FEEL的博客
06-21 647
文章目录1.动态内存分配1.1. 内存泄漏1.1.1 丢失地址1.1.2 隐式内存泄漏2. 动态内存分配函数 1.动态内存分配 使用malloc类的函数分配内存 使用分配的内存来支持应用程序 free函数释放内存 如下，分配内存并为内存中填充数据： int* p = (int*)malloc(sizeof(int)); *p = 990715; //为开辟的内存填充...
c语言动态内存分配
GOATLong的博客
03-25 1416
首先我们看一下该函数的声明：这个函数就是向操作系统申请一块连续可用的空间单位是字节并返回申请空间的地址。
【C语言】动态内存管理
m0_62537611的博客
05-09 1173
前言 指针、结构体和动态内存管理是后面学习数据结构的基础。正所谓基础不牢，地动山摇，还不快来跟着我的脚步一起学习。 目录 一、为什么存在动态内存分配 二、动态内存函数介绍 三、常见的动态内存函数的错误 1、为什么存在动态内存管理 我们已经掌握的内存开辟方式有： int a=10;//在栈空间开辟四个字节 int arr[10]={0};//在栈空间上开辟10个字节连续存放的空间 上述的开辟空间的方式有两个特点： 1. 空间开辟大小是固定的。 2. 数组在申明的时候，必须指定数组...
C语言之动态内存管理
m0_70749276的博客
10-06 637
c语言之动态内存存储
C-动态内存管理
CHAKMING1的博客
04-15 985
C语言超详细的动态内存管理知识
C动态内存管理
长期更新自学笔记
06-10 198
#include<stdio.h> #include<stdlib.h> // #include<vld.h> // 开辟堆区内存：malloc、calloc、realloc // 释放：free，不释放则会内存泄漏 // 泄露内存被回收的时候：进程退出时、系统重启 /* void* malloc(size_t size); void* 指的是通用地址，只知道地址在哪，而不知道该地址存放什么数据 void* calloc(size_t n..
C语言动态内存管理和最佳实践
最新发布
10-15
内容概要：本文详细讲解了C语言中的动态内存管理函数及其应用方法，介绍了使用malloc(), calloc(), realloc(), 和 free()函数来实现动态内存分配、释放的操作流程。通过对示例代码的逐步剖析，展示了如何有效地创建...
C语言动态内存管理笔记
03-09
个人学习总结
C语言实现内存管理
03-21
在编程世界中，C语言因其低级特性而被广泛用于系统级编程，其中包括内存管理。内存管理是程序设计中的核心部分，它涉及到如何有效地分配、使用和释放内存资源。本主题将深入探讨如何使用C语言来实现内存管理的关键...
[c/c++]——动态内存管理
lucky52529的博客
01-18 384
动态内存管理 前言 首先我们要明白数据的内存分配原则 来看几道题 这些答案是怎么来的呢，博主做了下面的总结 分配方式： [1]从静态存储区域分配。内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。例如全局变量，static变量。静态分配的区域的生命期是整个软件运行期，就是说从软件运行开始到软件终止退出。只有软件终止运行后，这块内存才会被系统回收 [2]在栈上创建。在执行...
C++动态内存管理(比较C动态内存管理)
静陌慕春
11-04 2597
首先我们先了解一下内存：C语言使用malloc/free动态管理内存空间，C++引入了new/delete，new[]/delete[]来动态管理内存。 介绍new/delete，new[]/delete[]之前我们先了解一下operator new，operator delete，operator new[]，operator delete[]函数。注：这些函数并没有重载new/delete表达
C基础语法（动态内存）
m0_61350245的博客
07-23 401
C语言动态内存分配详解
C/C++语言—动态内存管理
3166375975@的博客
09-08 1037
C/C++中程序内存区域划分：  C/C++程序内存区域划分  栈：又叫堆栈，存储非静态局部变量、函数参数、 返回值等，栈是可以向下生长的 内存映射区：是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口创建共享共享内 存，做进程间通信 堆：用于程序运行时动态内存分配，堆是可以向上增长的 数据段：存储全局数据和静态数据 代码段：存储可执行的代码、只读常量  C/C...
C/C++动态内存创建与内存管理
tattarrattat的专栏
11-15 1064
1 内存空间逻辑组织A 静态数据区：内存在程序启动的时候才被分配，而且可能直到程序开始执行的时候才被初始化，如函数中的静态变量就是在程序第一次执行到定义该变量的代码时才被初始化。所分配的内存在程序的整个运行期间都存在，如全局变量，static变量等。注意：初始化的全局变量和静态变量在一块区域，未初始化的全局变量与静态变量在相邻的另一块区域，同时未被初始化的对象存储区可以通过void*来访问
动态内存管理（C语言和C++中）
汐梦的博客
04-24 1226
一、 C语言动态内存管理 1.堆上开辟空间（malloc,calloc,realloc） 首先了解一下三者的函数原型。 void *malloc(size_t size);     malloc()在内存的动态存储区中分配一块长度为size字节的连续区域。参数size为需要的内存空间的长度，返回该区域的地址。并且没有初始化内存的内容,因此基本上malloc之后,调用函数memset来初始化...
C/C++动态内存管理
y6_xiamo的博客
08-20 245
C语言动态内存管理 C语言使用malloc、calloc、realloc来进行动态内存的管理。 malloc仅仅开辟一块空间，calloc开辟空间的同时并把它初始化为0，而realloc可以进行动态内存的调整。前面博客中已经介绍了这三个函数，在此不再赘述。 浅谈malloc、calloc和realloc //C动态内存管理 void Test() { int *p1 = (int...
C语言中的动态内存管理
SPMAX的博客
01-30 1713
前言在了解动态内存管理之前，我们要先了解关于c语言的内存中的栈区、堆区和静态区：栈区主要存储形式参数（也就是我们调用函数的时候一般会将我们定义的实参传入函数后所形成的参数），以及局部变量（比如说就是我们在main函数中定义的int A=10;等等的变量）。在栈区创立的变量在程序运行完后会自动回收，不需要我们去进行回收操作，而堆区是我们可以在堆区内存充裕时按照自己所需要的字节大小去主动申请空间的地方，我们称之为堆区，也就是我们下面主要要讲到的动态内存管理，相比于栈区更具有可操作性，需要自己去回收。最后一个时静
C语言动态内存管理实现通讯录系统
2. 动态内存管理：C语言中动态内存管理主要通过malloc和free函数实现。在本系统中，由于通讯录的联系人数量会随着用户的操作动态变化，因此需要动态地分配和回收内存空间，以满足存储需求。 3. 文件操作：系统支持...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值