【C语言初阶】动态内存分配实战指南：C 语言 4 大函数使用 + 经典笔试题 + 柔性数组优势与内存区域

小龙报2025-12-08 8:37

🔥小龙报：个人主页

🎬作者简介：C++研发，嵌入式，机器人等方向学习者

❄️个人专栏：《C语言》
✨ 永远相信美好的事情即将发生

文章目录

  • 前言
  • 一、为什么要有动态内存分配
  • 二、malloc和free
    • 2.1malloc
      • [2.1.1 函数原型与使用解析](#2.1.1 函数原型与使用解析)
    • [2.2 free](#2.2 free)
      • [2.2.1 函数原型与使用解析](#2.2.1 函数原型与使用解析)
    • [2.3 使用案例分析](#2.3 使用案例分析)
  • [三、 calloc和realloc](#三、 calloc和realloc)
    • [3.1 calloc](#3.1 calloc)
      • [3.1.1 函数原型与使用解析](#3.1.1 函数原型与使用解析)
      • [3.1.2 使用案例](#3.1.2 使用案例)
    • [3.2 realloc](#3.2 realloc)
      • [3.2.1 函数原型与使用解析](#3.2.1 函数原型与使用解析)
      • [3.2.2 realloc在调整内存空间的是存在两种情况](#3.2.2 realloc在调整内存空间的是存在两种情况)
        • [3.2.2.1 情况1：原有空间之后有足够大的空间](#3.2.2.1 情况1：原有空间之后有足够大的空间)
        • [3.2.2.2 情况2：原有空间之后没有足够大的空间](#3.2.2.2 情况2：原有空间之后没有足够大的空间)
  • 四、常见的动态内存的错误
    • [4.1 对NULL指针的解引用操作](#4.1 对NULL指针的解引用操作)
    • [4.2 对动态开辟空间的越界访问](#4.2 对动态开辟空间的越界访问)
    • [4.3 对非动态开辟内存使用free释放](#4.3 对非动态开辟内存使用free释放)
    • [4.4 使用free释放一块动态开辟内存的一部分](#4.4 使用free释放一块动态开辟内存的一部分)
    • [4.5 对同一块动态内存多次释放](#4.5 对同一块动态内存多次释放)
    • [4.6 动态开辟内存忘记释放（内存泄漏）](#4.6 动态开辟内存忘记释放（内存泄漏）)
  • 五、动态内存经典笔试题分析
    • [5.1 例1](#5.1 例1)
    • [5.2 例2](#5.2 例2)
      • [5.2.1 代码解析](#5.2.1 代码解析)
    • [5.3 例3](#5.3 例3)
      • [5.3.1 代码解析](#5.3.1 代码解析)
    • [5.4 例4](#5.4 例4)
    • [5.4.1 代码解析](#5.4.1 代码解析)
  • 六、柔性数组
    • [6.1 柔性数组的特点](#6.1 柔性数组的特点)
    • 6.2柔性数组的使用
    • [6.3 柔性数组的优势](#6.3 柔性数组的优势)
  • 七、总结C/C++中程序内存区域划分
  • 总结与每日励志

前言

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

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

c 复制代码 
1.int val = 20;   //在栈空间上开辟四个字节
 2.char arr[10] = {0};//在栈空间上开辟10个字节的连续空间

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

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

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

但是对于空间的需求，不仅仅是上述的情况。有时候我们需要的空间大小在程序运行的时候才能知道，那数组的编译时开辟空间的⽅式就不能满足了，因此动态内存开辟，让程序员自己可以申请和释放空间，就比较灵活了。

二、malloc和free

2.1malloc

2.1.1 函数原型与使用解析

c 复制代码 
void* malloc (size_t size);

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

（1）如果开辟成功，则返回⼀个指向开辟好空间的指针。

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

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

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

2.2 free

2.2.1 函数原型与使用解析

c 复制代码 
 void free (void* ptr);

函数作用 ：专门是用来做动态内存的释放和回收的
函数解析：

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

(2)如果参数ptr 是NULL指针，则函数什么事都不做。
注：malloc和free都声明在stdlib.h 头文件中

2.3 使用案例分析

c 复制代码 
#include <stdio.h>
#include <stdlib.h>
int main()
{
	int nums;
	scanf("%d", &nums);

	int* ptr = (int*)malloc(nums * sizeof(int));

	if (ptr == NULL)
	{
		printf("申请失败!\n");
		return 1;
	}
	
	for (int i = 0; i < nums; i++)
	{
		*(ptr + i) = i;
		printf("%d ", *(ptr + i));
	}
		
	free(ptr);
	ptr = NULL;  //释放置空否则ptr会成为野指针
	return 0;
}

运行结果：

三、 calloc和realloc

3.1 calloc

3.1.1 函数原型与使用解析

c 复制代码 
void* calloc (size_t num, size_t size);

函数作用 ：是为num 个大小为size 的元素开辟⼀块空间，并且把空间的每个字节初始化为0
函数解析：

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

3.1.2 使用案例

c 复制代码 
#include <stdio.h>
#include <stdlib.h>

int main()
{
	int nums;
	scanf("%d", &nums);


	int* p = (int*)calloc(nums, sizeof(int));

	if (p != NULL)
	{
		for (int i = 0; i < nums; i++)
			printf("%d ", *(p + i));
	}
	return 0;
}

运行结果：

3.2 realloc

3.2.1 函数原型与使用解析

c 复制代码 
void* realloc (void* ptr, size_t size);

函数作用 ：

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

（1）ptr 是要调整的内存地址

（2）size 调整之后新大小

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

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

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

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

总结：要扩展内存就直接原有内存之后直接追加空间，原来空间的数据不发生变化

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

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

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

4.1 对NULL指针的解引用操作

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

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

c 复制代码 
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);
}

注：动态开辟的空间使用数组形式访问下标也是从0开始

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

c 复制代码 
void test()
{
	int a = 10;
	int* p = &a;
	free(p);
}

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

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

注 ：free 的规则是必须释放 malloc/calloc/realloc 返回的完整内存块的起始地址，不能只释放其"一部分。

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

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

注 ：重复释放会触发未定义行为

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

c 复制代码 
#include <stdio.h>
void test()
{
	int* p = (int*)malloc(100);
	if (NULL != p)
	{
		*p = 20;
	}
}
int main()
{
	test();
	while (1);
}

运行结果：

注：

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

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

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

5.1 例1

c 复制代码 
#include <stdio.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;
}

运行结果：

5.1.1代码解析

(1) 传参方式错误:

GetMemory 的参数是 char *p （值传递），函数里给 p 分配内存时，只是修改了函数内部的临时变量 p ，并没有改变外部 str 的值。

所以调用 GetMemory(str) 后， str 仍然是 NULL 。

  1. 空指针操作

后续执行 strcpy(str, "hello world"); 时， str 是 NULL ，这属于空指针解引用，会导致程序崩溃。

  1. 内存泄漏（即使传参正确也会有）

就算修正传参，这段代码也没有释放分配的内存，会造成内存泄漏。

5.2 例2

c 复制代码 
#include <stdio.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;
}

运行结果：

5.2.1 代码解析

运行 Test 函数会出现未定义行为，具体表现可能是输出乱码、程序崩溃，原因如下：

核心错误：返回局部数组的地址

1.GetMemory 函数中， char p[] = "hello world"; 是局部数组，它的内存分配在栈空间中。

  1. 当 GetMemory 函数执行结束后，栈上的局部变量（包括 p ）会被销毁，对应的内存会被释放并可能被后续代码覆盖。

  2. return p; 返回的是局部数组 p 的地址，但此时该地址已经是无效的"野指针"。

后续影响

Test 函数中 str = GetMemory(); 拿到的是无效地址，执行 printf(str); 时，会尝试访问这个无效内存：

（1） 若内存未被覆盖，可能输出乱码；

（2）若内存已被覆盖或访问越界，会导致程序崩溃。

5.3 例3

c 复制代码 
#include <stdio.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;
}

运行结果：

5.3.1 代码解析

1.GetMemory 中调用 malloc(num) 时，内存分配可能失败（比如系统内存不足），此时 malloc 会返回 NULL 。

  1. 代码中没有检查 malloc 的返回值，直接执行 strcpy(str, "hello") ------如果 str 是 NULL ，就会触发空指针写入冲突，导致 0xC00000005 异常。

5.4 例4

c 复制代码 
#include <stdio.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;
}

运行结果：

5.4.1 代码解析

这是一个野指针操作的典型错误案例，我们一步步分析：

1.第3行：用 malloc 分配了100字节堆内存， str 指向这块内存。

2.第5行：调用 free(str) ，此时这块堆内存被释放，但 str 这个指针变量本身的值（内存地址）没有被清空，变成了野指针（指向无效内存的指针）。

  1. 第6行：判断 str != NULL ，因为 str 没有被置为 NULL ，这个条件会成立。

  2. 第8-9行：用 strcpy 往野指针指向的无效内存写数据，又用 printf 访问这块内存，这属于非法内存访问，会导致程序崩溃或者不可预测的行为。

六、柔性数组

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

例：

c 复制代码 
 struct st_type
 {
    int i;
    int a[0];  //柔性数组成员
 };

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

c 复制代码 
struct st_type
 {
    int i;
    int a[];   //柔性数组成员
 }

6.1 柔性数组的特点

（1） 结构中的柔性数组成员前面必须至少⼀个其他成员

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

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

例：

c 复制代码 
#include <stdio.h>
typedef struct st_type
{
	int i;
	int a[0];//柔性数组成员

}type_a;
int main()
{
	printf("%d\n", sizeof(type_a));//输出的是4
	return 0;
}

运行结果：

6.2柔性数组的使用

例：

c 复制代码 
#include <stdio.h>
#include <stdlib.h>

#include <stdio.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);
	return 0;
}

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

6.3 柔性数组的优势

c 复制代码 
#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;
}

对比6.2和6.3的两种实现方式可得：
第⼀个好处是 ：方便内存释放

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

连续的内存有益于提高访问速度，也有益于减少内存碎片，（其实，我个人觉得也没多高了，反正你跑不了要用做偏移量的加法来寻址

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

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

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

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

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

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

总结与每日励志

✨ 本文介绍了C语言中动态内存分配的相关知识，重点讲解了malloc、free、calloc和realloc等函数的使用方法与注意事项。文章首先阐述了动态内存分配的必要性，指出传统数组在编译时确定大小无法满足运行时灵活需求。随后详细解析了各个函数的参数、返回值及使用场景，并通过代码示例演示了正确用法。同时列举了常见的动态内存错误类型，如空指针解引用、越界访问、重复释放等，强调内存泄漏的危害。最后通过四道典型笔试题分析，深入剖析了动态内存使用中的常见陷阱，帮助读者掌握正确的内存管理技巧并讲解了柔性数组的相关知识。

相关推荐
m0_471199631 小时前
【JavaScript】Map对象和普通对象Object区别
开发语言·前端·javascript
心.c1 小时前
《从零开始：打造“核桃苑”新中式风格小程序UI —— 设计思路与代码实现》
开发语言·前端·javascript·ui
倔强菜鸟1 小时前
2025.11.21-GO语言入门(一)
开发语言·后端·golang
白露与泡影1 小时前
从 JDK 8 到 JDK 18，Java 垃圾回收的十次进化
java·开发语言·测试工具
一晌小贪欢1 小时前
Streamlit应用如何部署到 Streamlit Community Cloud（保姆级教程）
开发语言·阿里云·部署·部署上线·streamlit应用·streamlit部署
小龙报1 小时前
【算法通关指南：算法基础篇（三）】一维差分专题：1.【模板】差分 2.海底高铁
android·c语言·数据结构·c++·算法·leetcode·visual studio
小白程序员成长日记1 小时前
2025.12.07 力扣每日一题
算法·leetcode·职场和发展
不悔哥2 小时前
路由器特性——网络状态检测
linux·c语言·网络·tcp/ip·智能路由器
lsx2024062 小时前
CSS3 过渡
开发语言
热门推荐
01GitHub 镜像站点02【超详细教程】手把手教你从微软官网免费下载Windows 10官方原版ISO镜像（2025最新版）03智能库存管理的需求预测模型：从业务痛点到落地代码的完整实践04安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）05UV安装并设置国内源06React CVE-2025-55182漏洞排查与修复指南07BongoCat - 跨平台键盘猫动画工具08Linux下V2Ray安装配置指南09本地部署阿里最新开源的Z-Image10打造高效订单处理！ZKmall开源商城的统一履约中心架构解析