C语言动态内存管理（重点）

最新推荐文章于 2024-11-02 14:31:05 发布
最新推荐文章于 2024-11-02 14:31:05 发布
阅读量1.4k 收藏 31
点赞数 42
文章标签： c语言 动态内存 柔性数组
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_81723939/article/details/136863032
版权
本文详细介绍了C/C++中的动态内存分配，包括malloc、calloc、realloc函数的使用、它们之间的差异以及常见错误。还讨论了柔性数组的概念、特点和优势，以及内存区域划分在程序设计中的重要性。
摘要由CSDN通过智能技术生成

目录

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

2、malloc 和 free

2.1 malloc函数

2.2 free函数

3、calloc 和 realloc

3.1  calloc函数 

3.2  realloc 函数

3.3  realloc 和 malloc 区别

3.4  realloc 函数存在的问题

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

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

6、柔性数组 

6.1 补充 typedef 创建结构体

6.2 柔性数组的特点

6.3 柔性数组的使用

6.4 柔性数组的优势 

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

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

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

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

2、malloc 和 free

2.1 malloc函数

       malloc 函数是 C 语言中用于动态分配内存的函数之一，其声明在 <stdlib.h> 头文件中。该函数用于在程序运行时从堆（heap）中动态分配指定大小的内存空间，并返回一个指向该内存空间起始地址的指针。

void *malloc(size_t size);
  • size_t size：需要分配的内存空间大小，以字节为单位。

   malloc 函数返回一个 void 类型的指针，需要根据实际情况进行类型转换后使用。如果内存分配成功，则返回指向分配内存起始地址的指针；如果内存分配失败，则返回 NULL。

2.2 free函数

   free 函数是 C 语言中用于释放动态分配内存的函数，其声明在 <stdlib.h> 头文件中。当程序不再需要动态分配的内存空间时，应该使用 free 函数将该内存空间释放，以便系统可以重新利用这部分内存。 

void free(void *ptr);
  • void *ptr：指向先前由 malloc、calloc 或 realloc 返回的内存空间起始地址的指针。

       使用 free 函数后，内存空间将被标记为可用，并可以被后续的内存分配操作重新使用。但需要注意的是，尝试释放已经释放过的内存空间或者尝试释放静态分配的内存空间会导致未定义的行为，因此务必确保只对动态分配的内存空间使用 free 函数。

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

int main() 
{
    int *arr;
    int n = 5;

    // 动态分配包含5个整数的内存空间
    arr = (int *)malloc(n * sizeof(int));

    if (arr == NULL) 
    {
        perror("malloc");
        return 1;
    }

    // 将数组元素初始化为 0
    for (int i = 0; i < n; i++) 
    {
        arr[i] = 0;
    }

    // 打印数组元素
    for (int i = 0; i < n; i++) 
    {
        printf("%d ", arr[i]);
    }

    // 释放动态分配的内存
    free(arr);
    arr=NULL；
    return 0;
}

注：在 free 释放开辟的动态内存后，原来指向该内存首地址的指针仍然指向该地址，为了避免该指针成为野指针，在 free 释放完开辟的动态内存后最好将指向该内存的指针设置为NULL；

    free(arr);
    arr=NULL；

3、calloc 和 realloc

3.1  calloc函数 

calloc 函数是 C 语言中用于动态分配内存并初始化为零的函数，其声明在 <stdlib.h> 头文件中。与 malloc 函数不同的是，calloc 函数在分配内存空间的同时会将其初始化为零，这是 calloc 和 malloc 的主要区别之一。 

void *calloc(size_t num, size_t size);
  • size_t num：需要分配的元素个数。
  • size_t size：每个元素的大小，以字节为单位。

   calloc 函数会分配 num*size 个字节的内存空间，并将所有位初始化为零。如果内存分配成功，则返回指向分配内存起始地址的指针；如果内存分配失败，则返回 NULL。

#include <stdio.h>
#include <stdlib.h>
int main()
{
	int* p = (int*)calloc(10, sizeof(int));
	if (NULL != p)
	{
		int i = 0;
		for (i = 0; i < 10; i++)
		{
			printf("%d ", *(p + i));
		}
	}
	free(p);
	p = NULL;
	return 0;
}
3.2  realloc 函数

   realloc 函数是 C 语言中用于重新分配动态分配内存空间的函数，其声明在 <stdlib.h> 头文件中。当需要调整先前分配的内存空间的大小时，可以使用 realloc 函数来实现。realloc 函数会尝试扩大或缩小先前分配的内存块，并保留原始内存块中的数据。 

void *realloc(void *ptr, size_t size);
  • void *ptr：指向先前由 malloc、calloc 或 realloc 返回的内存空间起始地址的指针。
  • size_t size：重新分配后的内存空间大小，以字节为单位。

            如果重新分配成功，则返回指向新分配内存起始地址的指针；如果重新分配失败，则返回 NULL。值得注意的是，realloc 函数可能会将原内存块移动到新的位置，因此在调用 realloc 后应该谨慎处理原指针。

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

int main() 
{
    int *arr;
    int n = 5;

    // 动态分配包含5个整数的内存空间
    arr = (int *)malloc(n * sizeof(int));

    if (arr == NULL) 
    {
        printf("内存分配失败\n");
        return 1;
    }

    // 重新分配为包含10个整数的内存空间
    arr = (int *)realloc(arr, 10 * sizeof(int));

    if (arr == NULL) 
    {
        printf("内存重新分配失败\n");
        return 1;
    }

    // 打印数组元素
    for (int i = 0; i < 10; i++) 
    {
        printf("%d ", arr[i]);
    }
    // 释放动态分配的内存
    free(arr);
    arr=NULL;
    return 0;
}
3.3  realloc 和 malloc 区别

        malloc返回类型是 void 型指针，再根据实际需求进行强制类型转换，那么根据两个函数的定义就可以发现，当 realloc 函数第一个参数是空指针时那么就和 malloc 函数功能相同：

int* p = (int*)realloc(NULL,40);
3.4  realloc 函数存在的问题

        3.2 部分的示例代码首先使用 malloc 分配了包含5个整数的内存空间，然后使用 realloc 函数将内存空间重新分配为包含10个整数的空间。但是存在一个问题： 若 realloc 函数重新分配失败怎么办？会返回NULL，那么想重新分配的指针 arr = NULL，其原来指向的内存也不存在了。 

realloc 函数在重新分配内存空间时可能会返回 NULL，主要是由于以下几种情况导致的：

  1. 内存分配失败：当系统无法满足请求的内存空间大小时，realloc 函数会失败并返回 NULL。这通常发生在内存不足或者系统资源受限的情况下。

  2. 内存空间连续性不足：如果原内存块之后没有足够的连续空间来扩展到请求的大小，realloc 也会失败并返回 NULL。这种情况下，系统无法在原地扩展内存空间，需要将原内存块移动到新的位置，如果新位置无法提供足够的连续空间也会导致失败。

  3. 其他系统限制：某些系统可能会施加其他限制，例如内存碎片化程度过高、操作系统限制等，都有可能导致 realloc 返回 NULL。

情况1：

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

情况2： 

        realloc函数会在内存的堆区重新找一个空间（满足新的空间大小需求的），同时会把旧的数据拷贝到新的空间，然后释放旧的空间，同时返回新的空间的起始地址。

由于上述的两种情况，realloc函数的使⽤就要注意⼀些：

#include <stdio.h>
#include <stdlib.h>
int main()
{
	int* ptr = (int*)malloc(100);
	if (ptr != NULL)
	{
		//...
	}
	else
	{
		return 1;
	}
	//扩展容量
	//代码1 - 直接将realloc的返回值放到ptr中
	ptr = (int*)realloc(ptr, 1000);//如果申请失败会如何？

	//代码2 - 先将realloc函数的返回值放在p中，不为NULL，再放ptr中
	int* p = NULL;
	p = realloc(ptr, 1000);
	if (p != NULL)
	{
		ptr = p;
	}
    else
    {
        perror("realloc");
        return 1;
    }
	free(ptr);
	return 0;
}

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

（一） 对NULL指针的解引用操作

//可以先进行判断
#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)malloc(100);

	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	*p = 20;
	free(p);
	return 0;
}

（二） 对动态开辟空间的越界访问

（三）对非动态开辟内存使用free释放

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

使用 free 释放空间时给的不是起始地址。

（五）对同一块动态内存多次释放

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

        如下情况，在 test 函数中申请了100个字节的空间，并定义了p指向了这个空间。当函数调用结束后，函数定义的局部变量 p 随之销毁，同时也没有变量保存这块空间的地址，申请的这块内存空间后续将无法使用，因为不知道这块空间的地址。

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

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

题目一： 

#include<stdio.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);
}
int main()
{
	Test();
	return 0;
}

        分析上述代码，当将一个指针作为参数传递给函数时，实际上传递的是指针变量所存储的地址值的副本，而不是实际指针变量本身。这意味着在函数内部对传递进来的指针进行修改时，只会影响到形式参数的副本，而不会影响到原始指针变量的值。                                                                      在 GetMemory 函数中，参数 p 被传递为指针的副本，而不是指针本身。所以函数内部对 p 进行的内存分配不会影响到 Test 函数中原始指针 str 的值。当 GetMemory 函数返回时，分配的内存空间将丢失，因为只是修改了传递进来的副本指针 p 的值，而原始指针 str 仍然是 NULL。因此，strcpy 和 printf 函数中使用的 str 指针仍然是 NULL，对空指针解引用就会导致程序的崩溃。

修改后代码如下：

 题目二：

        分析上述代码。在 GetMemory 函数中，它尝试返回一个指向局部变量 p 的指针。然而，一旦 GetMemory 函数执行完毕并返回，p 所在的内存空间将被释放，因为它是一个自动变量（在栈上分配）。因此，当 Test 函数尝试使用从 GetMemory 返回的指针时，实际上它指向的是一个无效的内存位置，这可能导致未定义的行为。

可以在GetMemory函数中定义char p[ ]前加static，这样当执行完函数后这块空间仍然不会释放：

6、柔性数组 

6.1 补充 typedef 创建结构体

        使用 typedef 可以将复杂的数据类型简化为一个更容易记忆和理解的别名，使得代码更加清晰，减少出错的可能性。在 C 语言中，typedef 经常与结构体、枚举等复杂数据类型一起使用，方便在程序中定义新的类型名称。

        在如下代码中，通过 typedef 将 struct st_type 定义的结构体类型命名为 type_a，这样以后可以直接使用 type_a 来声明结构体变量，而不需要每次都写完整的 struct st_type。这种方式使得代码更加简洁明了，提高了代码的可读性和可维护性。

#include <stdio.h>

// 定义结构体 st_type
struct st_type 
{
    int i;
    char c;
};

// 使用 typedef 创建结构体别名 type_a
typedef struct st_type type_a;

int main() 
{
    // 声明一个结构体变量并赋初值
    type_a my_struct;
    my_struct.i = 10;
    my_struct.c = 'A';

    // 打印结构体变量的成员值
    printf("i: %d\n", my_struct.i);
    printf("c: %c\n", my_struct.c);

    return 0;
}
6.2 柔性数组的特点

        在 C 语言中，柔性数组（Flexible Array Member）是一种特殊的结构体成员，它允许在结构体的末尾定义一个长度不确定的数组。柔性数组通常用于动态分配内存，使得结构体可以容纳可变长度的数据。（1）在结构体中；（2）最后一个成员；（3）未知大小的数组。例如：

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

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

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

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

6.3 柔性数组的使用
#include <stdio.h>
#include <stdlib.h>

// 定义包含柔性数组的结构体
struct FlexArray 
{
    int length;
    int data[]; // 柔性数组，实际长度在运行时确定
};

int main() 
{
    int n = 5;

// 计算结构体大小并分配内存,前面的sizeof(struct FlexArray)分配给柔性数组前面的变量，后面的 n * sizeof(int)为柔性数组的大小
    struct FlexArray* flex = (struct FlexArray*)malloc(sizeof(struct FlexArray) + n * sizeof(int));

    if (flex == NULL) 
    {
        printf("Memory allocation failed\n");
        return 1;
    }

    flex->length = n;

    // 使用柔性数组存储数据
    for (int i = 0; i < n; i++) 
    {
        flex->data[i] = i * 2;
    }

    // 打印柔性数组中的数据
    printf("Data stored in flexible array:\n");
    for (int i = 0; i < flex->length; i++) 
    {
        printf("%d ", flex->data[i]);
    }

    // 释放内存
    free(flex);

    return 0;
}
6.4 柔性数组的优势 
#include <stdio.h>
#include <stdlib.h>
typedef struct st_type
{
	int i;
	int* p_a;
}type_a;
int main()
{
	int i = 0;
	type_a* p = (type_a*)malloc(sizeof(type_a));
	p->i = 100;
	p->p_a = (int*)malloc(p->i * sizeof(int));
	//处理
	for (i = 0; i < 100; i++)
	{
		p->p_a[i] = i;
	}
	for (int i = 0; i < 100; i++) 
    {
        printf("%d ", p->p_a[i]);
    }
	//释放空间
	free(p->p_a);
	p->p_a = NULL;
	free(p);
	p = NULL;
	return 0;
}

假如将6.3中的柔性数组换成 int*的指针，同样可以实现相同的功能 ，但是柔性数组更有优势：

拓展：C语言结构体里的数组和指针 

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

做完作业了
关注
C语言：动态内存管理
weixin_51142926的博客
01-17 1万+
学习数据结构之前，一定要对指针、结构体、动态内存管理进行深入学习！
C语言之动态内存管理
m0_70749276的博客
10-06 604
c语言之动态内存存储
C语言 动态内存管理
m0_72529141的博客
07-25 880
本文章主要总结了C语言中的动态内存管理问题
C语言的动态内存管理
carry_carial的博客
09-26 937
C语言动态内存开辟详细解释，不懂动态内存的同学们快来看一看呀
漫谈C语言内存管理
易水南风的专栏
07-10 2258
要学习音视频开发，首先C、C++是必备的编程语言，因为很多知名的音视频库，比如FFMPEG、X264等都是用C语言编写的，而我们要使用这些库就必须用C、C++去开发程序。 C语言是一门怎样的语言呢？C语言是一门面向过程的编译型语言，它的运行速度极快，仅次于汇编语言。**C语言是计算机产业的核心语言，操作系统、硬件驱动、关键组件、数据库等都离不开C语言**；不学习C语言，就不能了解计算机底层。后来的很多语言（C++、Java等）都参考了C语言，说C语言是现代编程语言的开山鼻祖毫不夸张，它改变了编程世界
C语言动态内存管理（详解版）
kele_xin的博客
04-15 2201
文章重点：1.为什么存在动态内存分配。 2.动态内存函数的使用（malloc、free、calloc、realloc）。 3.常见的动态内存错误。 4.举例几个经典的笔试题。 5.柔性数组的概念。6.使用C语言动态内存管理来实现通讯录小程序。 1.为什么存在动态内存分配？？？ ...
【C语言】动态内存管理（malloc，free，calloc，realloc详解 ）
学习之路，步步足迹；共享宝藏，笔记熠熠。点滴记录，历程不易；心得体会，共君品析。
08-09 1879
🦄。
C语言动态内存管理
yanghang666666的博客
12-07 847
C语言动态内存管理1.本章重点2.前言1.当前我们知道内存的使用方式1.创建一个变量2.创建一个数组3.提出问题：3.引出第一个问题：为什么存在动态内存分配1.分配涉及到的函数f1.malloc 1.本章重点 2.前言 1.当前我们知道内存的使用方式 1.创建一个变量 int a=10;//局部变量-栈区 int g_a=10;//全局变量—静态区 2.创建一个数组 int arr[10]; 3.提出问题： 不能控制创建数组的大小。（在C99标准下可以出现:int n;int arr[n];scanf(
C语言-动态内存管理
qq_60185118的博客
10-25 596
C语言 动态内存管理 malloc calloc realloc free函数
c语言动态内存分配知识点及实例
12-20
在C语言中，动态内存分配是一项重要的编程技巧，它允许程序员在程序运行时根据需要分配内存，而不是在编译期间预设固定...然而，动态内存管理也需要小心谨慎，防止出现常见的动态内存错误，确保程序的健壮性和可靠性。
C语言总结十一：内存划分、动态内存管理、变量分类详细总结
weixin_47040031的博客
12-22 1174
本篇博客针对内存的划分进行详细讲解，这与指针访问内存息息相关，因此清楚内存的划分区域至关重要，此外，栈区的空间大小相对较小，不够实际使用，相较于之前的静态数组，实际开发是一个动态变化的数组，可理解为顺序表，为方便进行管理，针对堆区的动态内存管理十分重要，本篇博客第二部分主要总结C语言中常用的动态内存函数malloc()、calloc()、realloc()、free(),以及常见的错误和经典的笔试题，最后对于常用的变量类型进行总结，这涉及到多文件编程，变量的生命周期等重要知识。
【C语言】深度剖析动态内存管理
StackFrame
09-25 1409
动态内存函数讲解、动态内存经典错误讲解
C语言-详细讲解-P1055 [NOIP2008 普及组] ISBN 号码
2402_86955314的博客
10-30 305
每一本正式出版的图书都有一个 ISBN 号码与之对应，ISBN 码包括 9 位数字、1 位识别码和 3 位分隔符，其规定格式如 x-xxx-xxxxx-x，其中符号 - 就是分隔符（键盘上的减号），最后一位是识别码，例如 0-670-82162-4就是一个标准的 ISBN 码。ISBN 码的首位数字表示书籍的出版语言，例如 0 代表英语；第一个分隔符 - 之后的三位数字代表出版社，例如 670 代表维京出版社；第二个分隔符后的五位数字代表该书在该出版社的编号；最后一位为识别码。 识别码的计算方法如下： 首位
ARM base instruction -- cinc
xiaozhi
10-31 458
ARM base instruction -- cinc
【C/C++】字符/字符串函数（2）——由string.h提供
bitenum的博客
11-02 513
内存越界了，于是报错。元素个数的情况没有区别。会在目标后追加'\0'，
C语言-详细讲解-洛谷P4414 [COCI2006-2007#2] ABC
2402_86955314的博客
10-29 244
【题目描述】 三个整数分别为 𝐴,𝐵,𝐶。这三个数字不会按照这样的顺序给你，但它们始终满足条件：𝐴
C语言稀有关键词：柔性数组
2401_88035751的博客
10-28 601
柔性数组的使用
MATLAB公路裂缝检测系统面板GUI.zip
11-02
圣诞树
Flask-2.1.3.tar.zip
最新发布
11-02
Flask-2.1.3.tar.zip
C语言动态内存分配详解：malloc与new运算符
"C语言内存分配详解，包括静态与动态内存分配，重点解析malloc函数的作用。动态内存分配允许程序在运行时根据需要分配内存，解决了静态分配的局限性，如数组大小固定和指针必须指向已存在的变量。C/C++中的内存分为...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

做完作业了

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值