动态内存管理-C语言进阶

已于 2023-11-12 16:27:46 修改
阅读量40 收藏
点赞数
分类专栏： C语言 文章标签： c语言 开发语言 1024程序员节
于 2023-10-24 11:28:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ma123456542/article/details/134004141
版权

本章重点

  • 为什么存在动态内存管理
  • 动态内存函数的介绍（在头文件 stdlib.h 中）
    • malloc
    • free
    • calloc
    • realloc
  • 常见的动态内存错误
  • 几个经典的笔试题
  • 柔性数组

1. 为什么存在动态内存分配

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

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

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

  1. 空间开辟大小是固定的。
  2. 数组在声明的时候，必须指定数组的长度，它所需要的内存在编译时分配。

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

2. 动态内存函数的介绍

2.1 malloc 和 free

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

void* malloc(size_t size);

这个函数向内存申请一块 size 字节的 连续可用 的空间（不初始化），并返回指向这块空间的指针。

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

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

void free(void* ptr);

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

  • 如果参数 ptr 指向的空间不是动态开辟的，那 free 函数的行为是未定义的。
  • 如果参数 ptr 是 NULL 指针，则函数什么事都不做。

举个例子：

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

int main() {
	//代码 1
	int arr[10] = { 0 };//在栈区开辟空间

	//代码 2
	int n = 0;
	scanf("%d", &n);
	int arr[n] = { 0 };//C99标准支持变长数组：数组的大小可以用变量指定

	//代码 3
	//1. 动态内存开辟
	int* p = (int*)malloc(40);//在堆区申请空间
	if (p == NULL) {
		printf("%s\n", strerror(errno));
		return 1;
	}
	//2. 使用动态内存
	int i = 0;
	for (i = 0; i < 10; i++) {
		*(p + i) = i;
	}
	for (i = 0; i < 10; i++) {
		printf("%d ", *(p + i));
	}
	//3
	free(p);//释放 p 所指向的动态内存空间，p 的值并没有改变(野指针)
	p = NULL;
	
	return 0;
}

没有free，并不是说内存空间就不回收了，当程序退出的时候，系统会自动回收内存空间的。

2.2 calloc

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

void* calloc(size_t num, size_t size);

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

int main() {
	int* p = (int*)calloc(10, sizeof(int));
	if (p == NULL) {
		printf("%s\n", strerror(errno));
		return 1;
	}
	//打印
	int i = 0;
	for (i = 0; i < 10; i++) {
		printf("%d ", *(p + i));
	}

	free(p);
	p = NULL;

	return 0;
}

C语言习惯：返回 0 表示 正常返回，返回 1 表示 异常返回。

2.3 realloc

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

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

  • ptr 是要调整的内存地址
  • size 调整之后新大小
  • 返回值为调整之后的内存起始位置。
  • 这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到新的空间。
  • realloc 在调整内存空间时存在两种情况：
    • 情况 1：原有空间之后有足够大的空间。（追加）
    • 情况 2：原有空间之后没有足够大的空间。（另外开辟）
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>

int main() {
	int* p = (int*)malloc(40);
	if (p == NULL) {
		printf("%s\n", strerror(errno));
		return 1;
	}
	//使用
	int i = 0;
	for (i = 0; i < 10; i++) {
		*(p + i) = i;
	}
	//扩容
	int* ptr = (int*)realloc(p, 80);
	if (ptr != NULL) {
		p = ptr;
	}
	//使用
	for (i = 0; i < 10; i++) {
		printf("%d ", * (p + i));
	}

	free(p);
	p = NULL;

	return 0;
}

警告⚠：
不要直接 p = (int*)realloc(p, 80);，如果 realloc 函数调整动态内存空间失败会返回 NULL 指针，p 指向 NULL 指针会导致无法找到原来指向的动态内存空间，造成内存泄漏！

realloc 特殊用法：

realloc(NULL, 40); <===> malloc(40);

3. 常见的动态内存错误

3.1 对 NULL 指针的解引用操作

void test() {
	int* p = (int*)malloc(INT_MAX / 4);
	*p = 20;
	free(p);
	p = NULL;
}

如果 p 的值是 NULL，就会有问题。

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

void test() {
	int* p = (int*)malloc(40);
	if (p == NULL) {
		exit(EXIT_FAILURE);
	}
	int i = 0;
	for (i = 0; i <= 10; i++) {
		*(p+i) = i;
	}
	free(p);
	p = NULL;
}

当 i = 10 时发生越界访问。

3.3 对非动态开辟空间使用 free 释放

void test() {
	int a = 10;
	int* p = &a;
	free(p);
	p = NULL;
}

如果指针 p 指向的空间不是动态开辟的，那 free 函数的行为是未定义的。（VS编译器中程序崩溃）

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

void test() {
	int* p = (int*)malloc(40);
	if (p == NULL) {
		exit(EXIT_FAILURE);
	}
	//使用
	int i = 0;
	for (i = 0; i < 5; i++) {
		*p = i;
		p++;
	}
	//释放
	free(p);
	p = NULL;
}

如果将指向动态内存空间的起始指针 p 改变了，释放时将会导致程序崩溃。

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

void test() {
	int* p = (int*)malloc(40);
	if (p == NULL) {
		exit(EXIT_FAILURE);
	}
	//使用
	//...
	//释放
	free(p);
	// ...
	//释放
	free(p);
}

会导致程序崩溃。

解决方法：free(p); 后将 p 赋为 NULL 指针，free(NULL); 相当于什么都不做，避免程序出错。

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

情况 1：

void test() {
	int* p = (int*)malloc(40);
	if (p == NULL) {
		exit(EXIT_FAILURE);
	}
	//使用
	//...

	int flag = 0;
	scanf("%d", &flag);
	if (flag == 5)
		return;

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

情况 2：

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

int* test() {
	//开辟空间
	int* p = (int*)malloc(40);
	if (p == NULL) {
		return p;
	}

	return p;
}

int main() {
	int* ret = test();
	//忘记释放了

	return 0;
}

4. 几个经典的笔试题

4.1 题目 1：

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

运行 test 函数会产生什么结果？

  • str 是 NULL 指针，解引用时会崩溃。
  • GetMemory 函数内部存在内存泄露。

正确的代码：

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

	//释放
	free(str);
	str = NULL;
}

int main() {
	test();

	return 0;
}

或者

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

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

printf 打印字符串传入的是 字符串首字符的地址。

  • printf(“hello”);
  • char* p = “hello”; printf(p);
  • char* p = “hello”; printf(“%s”, p);

5. C/C++程序的内存开辟

在这里插入图片描述

  • 内核空间：操作系统内核使用，用户程序无法使用。

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

  1. 栈区（stack）：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限，栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。
  2. 堆区（heap）：一般由程序员分配释放，若程序员不释放，程序结束时可能由 OS 回收。分配方式类似于链表。
  3. 数据段（又称静态 (static) 区）：存放静态数据和全局变量。程序结束后由系统释放。
  4. 代码段：存放函数体（类成员函数和全局函数）的二进制代码和只读常量（常量字符串等）。

由此，我们更好的理解 static 关键字修饰局部变量的例子：

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

6. 柔性数组

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

例如：

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

a[0] 表示数组大小没有指定/不知道数组的大小。

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

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

6.1 柔性数组的特点：

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

例如：

#include <stdio.h>

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

int main() {
	printf("%d ", sizeof(type_a));//4

	return 0;
}

6.2 柔性数组的使用

#include <stdio.h>

typedef struct st_type {
	int i;
	int arr[0];
} type_a;

int main() {
	type_a* ps = (type_a*)malloc(sizeof(type_a) + 40);
	if (ps == NULL) {
		return 1;
	}
	//使用
	ps->i = 100;
	int i = 0;
	for (i = 0; i < 10; i++) {
		ps->arr[i] = i;
		ptr = NULL;
	}
	for (i = 0; i < 10; i++) {
		printf("%d ", ps->arr[i]);
	}
	//扩容
	type_a* ptr = (type_a*)realloc(ps, sizeof(type_a) + 80);
	if (ptr != NULL) {
		ps = ptr;
		ptr = NULL;
	}
	//...
	
	//释放
	free(ps);
	ps = NULL;

	return 0;
}

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

6.3 柔性数组的优势

上述 type_a 结构体也可以设计为：

#include <stdio.h>

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

int main() {
	type_a* ps = (type_a*)malloc(sizeof(type_a));
	ps->i = 100;
	ps->parr = (int*)malloc(ps->i * sizeof(int));
	
	int i = 0;
	for (i = 0; i < 100; i++) {
		ps->parr[i] = i;
	}

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

上述 两个代码 可以完成同样的功能，但是 柔性数组的实现有两个好处：
第一个好处是： 方便内存释放

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

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

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

7. 练习

源于 《高质量的 C/C++ 编程》

代码 1：

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

GetMemory 函数返回了 字符数组 p 的地址（返回值存到了寄存器里），但是当函数结束返回后，字符数组 p 的空间就还给操作系统了，不属于当前程序了，那么这块空间未来分配给了谁，内容变成什么，我们都不知道。所以 str 就是野指针。（返回栈空间地址的问题）

因此：原来字符数组 p 的空间可能被别人使用，被覆盖；也有可能保留原来的值。

代码 2：

#include <stdio.h>

int* test() {
	int a = 10;
	return &a;
}

int main() {
	int* p = test();
	printf("hehe\n");
	printf("%d\n", *p);
	
	return 0;
}

调用 printf("hehe\n"); 函数要开辟函数栈帧对调用 test(); 函数的栈底空间进行了重新使用，导致了内容覆盖，因此 p 指向的内容发生了改变；如果没有调用 printf("hehe\n"); 函数，那么 p 指向的内容可能没有被覆盖，导致还是保留原来 a 的值。

注意：
返回 栈空间的地址 让指针接收是非常危险的操作。(因为栈区上所创建的变量都是临时的，这些临时变量可能暂时可以使用，回头就不能使用了)（返回栈空间地址的问题）

代码 3：

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

仅存在指针释放问题。

代码 4：（源于 高质量 C/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;
}
  • str 是野指针，但是程序不会报错。
  • 解决方法就是在 free 后置 NULL 指针。
_Amor_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C语言进阶---动态内存管理.md
04-03
动态内存空间开辟的详细讲解
C语言进阶-深度剖析.zip
10-15
《C语言进阶-深度剖析》是一本专为已经掌握C语言基础的读者设计的教程，旨在通过深度剖析，帮助读者提升对C语言的理解和应用能力。本压缩包包含的"**C语言进阶-深度剖析.pdf**"是完整的电子书资源，详细讲解了C语言...
05-C语言进阶——动态内存管理
11-25 4304
动态内存管理一、为什么要动态内存分配？二、动态内存函数函数介绍2.1malloc2.2 free2.3 calloc2.4 realloc三、常见动态内存错误3.1 对NULL指针的解引用操作3.2 对动态开辟空间的越界访问3.3 对非动态开辟内存使用free释放3.4 使用free释放一块动态开辟内存的一部分3.5 对同一块动态内存多次释放3.6 动态开辟内存忘记释放（内存泄漏） 一、为什么要动态内存分配？ 前面用到的内存开辟方式为在栈上开辟空间，例如： int val = 20;//在栈空间上开辟四个字
C语言进阶--动态内存管理
weixin_36194037的博客
06-29 688
C语言进阶--动态内存管理
C语言进阶-动态内存管理/柔性数组
~
10-01 1213
动态内存管理的使用即注意事项有关于动态内存管理的寄到笔试题讲解柔性数组的使用为什么存在动态内存分配一般的开辟空间方式：//在栈空间上开辟四个字节//在栈空间上开辟10个字节的连续空间特点：空间开辟大小是固定的（数组申明必须指定数组的长度，它所需要的内存在编译时分配）但有时候我们需要的空间大小在程序运行的时候才能知道， 那数组的编译时开辟空间的方式就不能满足了，由此动态内存开辟就来了动态内存函数的介绍。
嵌入式学习Day15---C语言进阶
m0_65301172的博客
07-28 431
2024年7月27日，学习的第15天。C语言终于尾声啦，再有最后一天讲完链表就结束了。加油！
C语言进阶-动态内存管理
m0_56900257的博客
03-08 891
这个函数向内存申请一块连续可用的空间，并返回指向这块空间的指针。如果开辟成功，则返回一个指向开辟好空间的指针。如果开辟失败，则返回一个NULL指针,因此malloc的返回值一定要做检查。返回值的类型是void*，所以malloc函数并不知道开辟空间的类型，具体在使用的时候来决定。如果参数 size 为0，malloc的行为标准是未定义的，取决于编译器。int main()//动态开辟return 1;//使用i < 10;i++)//即使没有free。
c语言进阶-动态内存管理
myz1016的博客
07-07 305
返回值是无类型的指针，指向分配的内存的首地址。申请失败会返回空指针。Malloc 内存申请函数。
C语言进阶——动态内存管理
xcxhzjl的博客
12-14 1050
C语言进阶---动态内存管理
weixin_75128035的博客
09-27 1131
中秋佳节倍思亲 千里同赏十五月 中 秋 节 快 乐 ʚ🥮ɞ Ɱօօղ ↻ąҟҽ 愿你千山暮雪海棠依旧🌟🌖🥮 不为岁月惊扰平贴忧愁 ☁ᕱ⑅ᕱ🔅
C语言进阶：动态内存管理
yourfriendyo的博客
09-28 1245
文章目录动态内存管理动态内存分配的意义动态内存函数的介绍开辟释放函数 `malloc` & `free`函数声明函数用法内存开辟函数 `calloc`函数声明函数用法内存调整函数 `realloc`函数声明函数用法常见的动态内存错误1.不检查空指针2.越界访问3.释放非动态开辟内存4.释放部分内存5.重复释放内存6.忘记释放内存笔试题Example 1Example 2Example 3Example 4C/C++内存划分用例展示内存划分图示柔性数组柔性数组的定义柔性数组的特点柔性数组的使用Exam
C语言进阶篇
热门推荐
Tian_baby的博客
02-22 1万+
B站鹏哥C语言进阶课程笔记。
c语言进阶_C语言进阶_源码
10-02
预处理器、内存管理及错误处理也是C语言进阶的重要部分。预处理器宏可以用来实现代码的条件编译和宏定义，内存管理则涉及到动态内存分配和释放，如malloc、calloc、realloc和free等函数的使用。错误处理则是编程中不...
C语言核心技术-C语言进阶用书PDF
05-20
通过malloc和free函数，程序员可以直接分配和释放内存，实现动态内存管理。不过，这也要求开发者对内存泄漏和悬挂指针有深入理解，避免潜在的运行时错误。 预处理器在C语言中扮演着重要角色，它处理宏定义、包含...
嵌入式C语言培训-编程进阶-1数组
12-19
在IT行业中，嵌入式系统开发是至关重要的领域，而C语言因其高效、灵活和对硬件的直接控制能力，成为了嵌入式编程的首选语言。...观看"嵌入式C语言培训-编程进阶-1数组.mp4"视频，将有助于进一步提升你的数组操作技巧。
C语言系统调用linux文件系统
C or CPP
07-25 912
在C语言中，openwrite和read函数是系统调用（system calls），它们直接由操作系统提供，用于底层的文件操作。这些函数是UNIX和类UNIX系统（如Linux）中的标准接口，不同于C标准库中的文件操作函数（如fopenfwrite和fread。
主流开发语言和开发环境介绍
weixin_44215445的博客
07-23 1748
主流开发语言和开发环境介绍
chromedriver-mac-arm64_127.0.6511.0.zip
07-31
chromedriver-mac-arm64_127.0.6511.0.zip
chromedriver-mac-arm64_128.0.6576.0.zip
07-31
chromedriver-mac-arm64_128.0.6576.0.zip
chromedriver-mac-x64_121.0.6115.2.zip
最新发布
07-31
chromedriver-mac-x64_121.0.6115.2.zip
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值