文档建议反馈控制台
首页
学习
活动
专区
圈层
工具
MCP广场
文章/答案/技术大牛
发布
社区首页 >专栏 >【C语言动态内存管理】--动态内存分配的意义，malloc和free，calloc和realloc，常见的动态内存的错误，动态内存经典笔试题分析，柔性数组，总结C/C++中程序内存区域划分

【C语言动态内存管理】--动态内存分配的意义，malloc和free，calloc和realloc，常见的动态内存的错误，动态内存经典笔试题分析，柔性数组，总结C/C++中程序内存区域划分

作者头像
草莓熊Lotso
发布于 2025-10-29 13:36:37
发布于 2025-10-29 13:36:37
3130
举报
文章被收录于专栏：C++/LinuxC++/Linux

🔥个人主页：@草莓熊Lotso的个人主页 🎬作者简介：C++研发方向学习者 📖个人专栏：《C语言》 ⭐️人生格言：生活是默默的坚持，毅力是永久的享受。

一.动态内存分配的意义

--我们在之前的学习中掌握了两种内存开辟方式：

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

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

  • 空间开辟的大小是固定的。
  • 数组在声明的时候，必须指定数组的长度，数组空间大小确定了不好调整

但有时候我们需要的空间大小在程序运行的时候才能知道，那数组的编译时开辟空间的方式就不能满足我的需要了。所以C语言引入了动态内存开辟，让程序员自己申请和释放空间，这就比较灵活了。

二.malloc和free

2.1--malloc函数

--我们先来介绍一个C语言中提供的一个动态内存开辟的函数；

1. void* malloc (size_t size);

功能： 这个函数会向内存在堆区申请⼀块连续可用的空间。

参数：size，申请空间的大小(比如我要申请一个10个整型大小的空间，就是10*sizeof(int))

返回值：返回指向申请的空间的指针

注意事项：

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

2.2--free函数

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

1. void free ( void * ptr);

功能：释放动态开辟的内存

参数：ptr指针，指向所要释放的动态开辟的空间

返回值：无

注意事项：

  • 如果参数 ptr 指向的空间不是动态开辟的，那free函数的行为是未定义的。
  • 如果参数 ptr 是NULL指针，则函数什么事都不做。
  • malloc和free都声明在 stdlib.h 头文件中。

2.3--malloc和free的使用

代码语言：javascript
复制
#include<stdio.h>
#include<stdlib.h>

int main()
{
	int n = 0;
	printf("请输入你所要申请的个数：");
	scanf("%d", &n);//输入个数
	//申请一块空间，用来存放数字
	int* p = (int*)malloc(n * sizeof(int));
	if (p == NULL)//判断
	{
		perror("malloc");
		return 1;
	}
	//使用内存空间
	for (int i = 0;i < n;i++)
	{
		p[i] = i + 1;
		printf("%d ", p[i]);
	}
	free(p);//用完之后及时释放
	p = NULL;//及时置为空指针1，防止变为野指针
	return 0;
}

三.calloc和realloc

3.1--calloc函数

--C语言还提供了一个函数calloc也可以用来动态内存分配；

1. void* calloc (size_t num, size_t size);

功能：为 num 个大小为 size 的元素开辟⼀块空间，并且把空间的每个字节初始化为0(作用等同于malloc+memset)。

参数：num，个数；size，每个的大小。(比如我要申请一个10个整型大小的空间，num就是10,size就是sizeof(int))

返回值：返回指向申请的空间的指针

与malloc的差异：

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

举例：

代码语言：javascript
复制
#include<stdio.h>
#include<stdlib.h>

int main()
{
	int n = 0;
	printf("请输入你所要申请的个数：");
	scanf("%d", &n);//输入个数
	//申请一块空间，用来存放数字
	int* p = (int*)calloc(n ,sizeof(int));
	if (p == NULL)//判断
	{
		perror("malloc");
		return 1;
	}
	//使用内存空间
	for (int i = 0;i < n;i++)
	{
		printf("%d ", p[i]);
	}
	free(p);//用完之后及时释放
	p = NULL;//及时置为空指针1，防止变为野指针
	return 0;
}

我们可以看到这样默认打出来的全是0，所以如果我们对申请的内存空间的内容要求初始化，那么可以很方便的使用calloc函数来完成任务。

3.2--realloc函数

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

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

参数：ptr 是要调整的内存地址 ；size 调整之后新大小

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

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

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

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

我们来分别看看这两种情况吧~

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

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

画图对比：

代码运行对比：在X86下是情况一，X64下是情况二，我们运行代码之后观察一下。

代码语言：javascript
复制
#include<stdio.h>
#include<stdlib.h>

int main()
{
	//申请一块空间，用来存放数字
	int* p = (int*)malloc(5*sizeof(int));
	if (p == NULL)//判断
	{
		perror("malloc");
		return 1;
	}
	//使用内存空间
	for (int i = 0;i < 5;i++)
	{
		p[i] = i + 1;
	}
	//继续存放6~10
	//空间不够了,需要增容
	int* ptr = realloc(p, 10 * sizeof(int));
	if (ptr == NULL)
	{
		perror("realloc");
		return 1;
	}
	p = ptr;
	//继续使用
	for (int i = 5;i < 10;i++)
	{
		p[i] = i + 1;
		printf("%d ", p[i]);
	}
	free(p);//用完之后及时释放
	p = NULL;//及时置为空指针1，防止变为野指针
	return 0;
}

x86环境：

x64环境：

我们可以很直观的看到情况一地址相同，情况二不同。

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

4.1--对NULL指针的解引用操作

代码语言：javascript
复制
#include<stdio.h>
#include<stdlib.h>

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

修改方案：在使用之前，要先对malloc，realloc，calloc这种函数的返回值进行判断，如果为空，将它的错误信息打印出来，并直接返回

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

代码语言：javascript
复制
#include<stdio.h>
#include<stdlib.h>

int main()
{
	//申请一块空间，用来存放数字
	int* p = (int*)malloc(5*sizeof(int));
	if (p == NULL)//判断
	{
		perror("malloc");
		return 1;
	}
	//使用内存空间
	for (int i = 0;i < 10;i++)
	{
		p[i] = i + 1;//当i=5时就越界访问了
		printf("%d ", p[i]);
	}
	free(p);
	p = NULL;
	return 0;
}

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

代码语言：javascript
复制
#include<stdio.h>
#include<stdlib.h>

int mian()
{
	int a = 10;
    int* p = &a;
    //使用
    //………………
    free(p);//ok?--no
    return 0;
}

注意：free只能释放malloc，realloc，calloc函数在堆区申请的空间，栈区上的空间会自己销毁的。

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

代码语言：javascript
复制
#include<stdio.h>
#include<stdlib.h>

int main()
{
	//申请一块空间，用来存放数字
	int* p = (int*)malloc(5*sizeof(int));
	if (p == NULL)//判断
	{
		perror("malloc");
		return 1;
	}
	//使用内存空间
	for (int i = 0;i < 5;i++)
	{
		*p = 1 + i;
		p++;
	}
	free(p);//free释放空间的时候，一定要给这块空间的起始位置
	p = NULL;
	return 0;
}

修改方案： free释放空间的时候，一定要给这块空间的起始位置，所以在这里使用内存空间时，直接用p[i]=i+1或者*(p+i)=i+1，不要用p++；

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

代码语言：javascript
复制
#include<stdio.h>
#include<stdlib.h>

int main()
{
	int* p = (int*)malloc(10*sizeof(int));
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	//使用内存空间
	//…………
	free(p);
	//…………
	free(p);
	p = NULL;
	return 0;
}

4.6--动态开辟内存忘记释放(内存泄漏)

代码语言：javascript
复制
#include<stdio.h>
#include<stdlib.h>

void test()
{
	int* p = (int*)malloc(10 * sizeof(int));
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
}
int main()
{
	test();
	//…………
	//…………
	
	return 0;
}

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

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

  • 谁申请的空间，谁释放
  • 不使用的空间，及时释放
  • 自家(函数1)不方便释放的空间，要告诉别人(函数2)释放

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

5.1--题目1：

代码语言：javascript
复制
#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 world");
	printf(str);
}
int main()
{
	Test();
	return 0;
}

题目解析：

  1. 程序崩溃，因为str传递给GetMemory函数的时候，采用的值传递形参变量p其实是str的一份拷贝，当我们把malloc申请的空间的起始地址存放在p中时不会修改str，str依然NULL，所以当GetMemory函数返回后，再去调用strcpy函数需要将 : "hello，word" 拷贝到str指向的空间时，程序崩溃。
  2. 因为malloc申请的空间没有free释放，存在内存泄漏。

修改后：

代码语言：javascript
复制
#include<stdio.h>
#include<stdlib.h>
#include<string.h>

void GetMemory(char** p)
{
	*p = (char*)malloc(100);//1
}
void Test(void)
{
	char* str = NULL;
	GetMemory(&str);//2
	strcpy(str, "hello world");
	printf(str);
}
int main()
{
	Test();
	return 0;
}

5.2--题目2：

代码语言：javascript
复制
#include<stdio.h>
#include<stdlib.h>
#include<string.h>

char* GetMemory(void)
{
	char p[] = "hello world";
	return p;
}
void Test(void)
{
	char* str = NULL;
	str = GetMemory();
	printf(str);
}
int main()
{
	Test();
	return 0;
}

题目解析：

  1. p是数组名在这里就是数组首元素地址，返回的是地址，但是是在栈区存储的，函数调用结束后会销毁，地址存放的也不一定是原来的东西了，所以会打印出随机值。
  2. 如果这里是用malloc这类函数在堆区动态开辟的空间，返回地址没有影响，或者用static修饰数组，改变其生命周期，即存储位置，从栈区到静态区，我们等会就用这个方法来修改这个代码看看。

修改后：

代码语言：javascript
复制
#include<stdio.h>
#include<stdlib.h>
#include<string.h>

char* GetMemory(void)
{
	static char p[] = "hello world";//static修饰的数组是存放在内存的静态区的
	return p;
}
void Test(void)
{
	char* str = NULL;
	str = GetMemory();
	printf(str);
}
int main()
{
	Test();
	return 0;
}

5.3--题目3：

代码语言：javascript
复制
#include<stdio.h>
#include<stdlib.h>
#include<string.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);
}
int main()
{
	Test();
	return 0;
}

题目解析：

  1. 这里可以打印出hello来，但是还是存在一些问题，这里malloc申请的空间在使用完后，始终没有free释放，造成了内存泄漏。

修改后：

代码语言：javascript
复制
#include<stdio.h>
#include<stdlib.h>
#include<string.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;
}

5.4--题目4：

代码语言：javascript
复制
#include<stdio.h>
#include<stdlib.h>
#include<string.h>

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

题目解析：

  1. 这里free使用后没及时将str置为空，它就会成为野指针，野指针就很危险了，所以后面才通过了判断，打印出了world。
  2. 还有就是使用malloc的返回值时也没有进行判断，万一是空指针，strcpy的使用就会出问题了。

修改后：

代码语言：javascript
复制
void Test(void)
{
	char* str = (char*)malloc(100);
	if (str == NULL)
	{
		printf("malloc");
		return 1;
	}
	strcpy(str, "hello");
	free(str);
	str = NULL;
	if (str != NULL)
	{
		strcpy(str, "world");
		printf(str);
	}
}
int main()
{
	Test();//什么也不会打印出来
	return 0;
}

六.柔性数组

--我们接下来了解一下柔性数组的概念，C99中，结构中的最后一个元素可以是未知大小的数组，这就叫做柔性数组成员，它的优势在于我们可以调整其空间大小。

例如：

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

6.1--柔性数组的特点

  • 结构中的柔性数组成员前面必须至少⼀个其他成员。
  • sizeof 返回的这种结构大小不包括柔性数组的内存。
  • 包含柔性数组成员的结构用malloc ()函数进行内存的动态分配，因为使用之前的方法无法给柔性数组分配空间，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小。

例如：

代码语言：javascript
复制
#include<stdio.h>
#include<stdlib.h>
#include<string.h>


struct s
{
	int n;
	int arr[];//柔性数组成员
};
int main()
{
	printf("%zu\n", sizeof(struct s));//4,没有算上柔性数组成员
	return 0;
}

6.2--柔性数组的使用

代码语言：javascript
复制
#include<stdio.h>
#include<stdlib.h>
#include<string.h>

struct s
{
	int n;
	int arr[];//柔性数组成员
};
int main()
{
	struct s* ps = (struct s*)malloc(sizeof(struct s) + 10 * sizeof(int));
	//后面这个10 * sizeof(int)是给柔性数组成员申请的空间大小
	if (ps == NULL)
	{
		perror("malloc");
		return 1;
	}
	//使用这块空间
	ps->n= 100;
	int i = 0;
	for (i = 0;i < 10;i++)
	{
		ps->arr[i] = i + 1;
	}
	//调整空间
	struct s* tmp = realloc(ps, sizeof(struct s) + 20 * sizeof(int));
	if (tmp == NULL)
	{
		perror("realloc");
		return 1;
	}
	ps = tmp;
	//继续使用空间
	//…………
	
	//释放
	free(ps);
	ps = NULL;
	return 0;
}

这里的柔性数组刚开始获得了10个整型元素的连续空间 ，后面调整空间到20个。

6.3--柔性数组的优势

--上面的使用，也可以通过下面这种方式来实现，我们对比着看一下吧。

代码语言：javascript
复制
#include<stdio.h>
#include<stdlib.h>
#include<string.h>

struct s
{
	int n;
	int *arr;
};
int main()
{
	struct s* ps = (struct s*)malloc(sizeof(struct s)); 
	if (ps == NULL)
	{
		perror("malloc");
		return 1;
	}
	ps->n = 100;
	int* ptr = (int*)malloc(10 * sizeof(int));
	if (ps == NULL)
	{
		perror("malloc2");
		return 1;
	}
	ps->arr = ptr;
	//存放1~10
	int i = 0;
	for (i = 0;i < 10;i++)
	{
		ps->arr[i] = i + 1;
	}
	//调整空间
	ptr= realloc(ps->arr,20 * sizeof(int));
	if (tmp == NULL)
	{
		perror("realloc");
		return 1;
	}
	ps->arr=ptr;
	//继续使用空间
	//…………

	//释放
	free(ps->arr);
	free(ps);
	ps = NULL;
	return 0;
}

上述两种方法可以完成同样的功能，但是方法1使用柔性数组来实现有两个好处：

  1. 第一个好处是：方便内存释放，如果我们的代码是在⼀个给别⼈用的函数中，你在里面做了二次内存分配，并把整个结构体返回给用户。用户调用free可以释放结构体，但是用户并不知道这个结构体内的成员也需要free，所以你不能指望用户来发现这个事。所以，如果我们把结构体的内存以及其成员要的内存⼀次性分配好了，并返回给用户⼀个结构体指针，用户做⼀次free就可以把所有的内存也给释放掉。
  2. 第二个好处是：这样有利于访问速度，连续的内存有益于提高i访问速度，也有益于减少内存碎片，但是提升也不会很大，你还是要用做偏移量的加法来寻址。

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

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

  1. 栈区（stack）：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。 栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。感兴趣的可以看下我的这篇博客【进阶】--函数栈帧的创建和销毁详解
  2. 堆区（heap）：⼀般由程序员分配释放， 若程序员不释放，程序结束时可能由OS（操作系统） 回收 ，分配方式类似于链表。
  3. 数据段（静态区）：（static）存放全局变量、静态数据。程序结束后由系统释放。
  4. 代码段：存放函数体（类成员函数和全局函数）的二进制代码。

往期回顾：

【自定义类型-结构体】--结构体类型，结构体变量的创建和初始化，结构体内存对齐，结构体传参，结构体实现位段

【自定义类型-联合和枚举】--联合体类型，联合体大小的计算，枚举类型，枚举类型的使用

结语:本篇文章就到此结束了，继前面一篇文章后,在此篇文章中给大家分享了C语言动态内存管理中的动态内存分配的意义，malloc和free，calloc和realloc，常见的动态内存的错误，动态内存经典笔试题分析，柔性数组，总结C/C++中程序内存区域划分等知识点，后续会继续给分享其它内容，如果文章对你有帮助的话，欢迎评论，点赞，收藏加关注，感谢大家的支持

本文参与 腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。
原始发表：2025-10-29，如有侵权请联系 cloudcommunity@tencent.com 删除
数组
malloc
程序
内存
内存管理

本文分享自 作者个人站点/博客 前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体同步曝光计划  ，欢迎热爱写作的你一起参与！

数组
malloc
程序
内存
内存管理
评论
登录后参与评论
0 条评论
热度
最新
登录 后参与评论
推荐阅读
目录
  • 一.动态内存分配的意义
  • 二.malloc和free
    • 2.1--malloc函数
    • 2.2--free函数
    • 2.3--malloc和free的使用
  • 三.calloc和realloc
    • 3.1--calloc函数
    • 3.2--realloc函数
  • 四.常见的动态内存的错误
    • 4.1--对NULL指针的解引用操作
    • 4.2--对动态开辟空间的越界访问
    • 4.3--对非动态开辟内存使用free释放
    • 4.4--使用free释放一块动态开辟内存的一部分
    • 4.5--对同一块动态内存多次释放
    • 4.6--动态开辟内存忘记释放(内存泄漏)
  • 五.动态内存经典笔试题分析
    • 5.1--题目1：
    • 5.2--题目2：
    • 5.3--题目3：
    • 5.4--题目4：
  • 六.柔性数组
    • 6.1--柔性数组的特点
    • 6.2--柔性数组的使用
    • 6.3--柔性数组的优势
  • 七.总结C/C++中程序内存区域划分
领券

腾讯云开发者

扫码关注腾讯云开发者

扫码关注腾讯云开发者

领取腾讯云代金券

热门产品

热门推荐

更多推荐

Copyright © 2013 - 2025 Tencent Cloud. All Rights Reserved. 腾讯云 版权所有 

深圳市腾讯计算机系统有限公司 ICP备案/许可证号：粤B2-20090059 深公网安备号 44030502008569

腾讯云计算（北京）有限责任公司 京ICP证150476号 |  京ICP备11018762号 | 京公网安备号11010802020287

问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档

Copyright © 2013 - 2025 Tencent Cloud.

All Rights Reserved. 腾讯云 版权所有

登录 后参与评论