c语言十七：动态内存申请

已于 2022-05-05 15:40:46 修改
阅读量5.9k 收藏 59
点赞数 10
分类专栏： c语言 文章标签： c语言
于 2022-03-14 10:29:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33808440/article/details/123398021
版权

动态内存申请

一 动态内存申请

  1. 数组的长度是预先定义好的，在整个程序中固定不变；
  2. 但在实际应用中，往往有这种情况，所需要的内存空间取决于实际输入的数据，而无法预先确定
  3. 为了解决上面的问题，C语言提供了一些内存管理函数，这些内存管理函数可以安装需要动态的分配内存空间，也可以把不再使用的内存空间回收再利用

二 静态分配内存和动态分配内存

2.1 静态分配内存

  1. 在程序编译或运行过程中，按事先规定好的大小分配内存空间的分配方式；
  2. 必须事先知道所需空间的大小；
  3. 空间是分配在栈区或全局变量区的；
  4. 按计划分配

2.2 动态分配内存

  1. 在程序运行过程中按需要自由分配所需空间；
  2. 按需分配；
  3. 空间是分配在堆区的，一般使用特点函数来分配

三 动态内存申请的相关函数

3.1 分配内存空间函数 malloc

函数功能： 在内存的动态存储器（堆区）中分配一块长度为size字节的连续内存空间，用来存放类型说明符指定的数据类型
函数原型： void *malloc(unsigned int num_bytes);
				形参num_bytes是需要申请内存空间的字节数
调用形式： (类型说明符*) malloc(size)
返回值：
		分配成功：分配的内存空间的起始地址
		分配失败：NULL
注意事项：
		1. 对malloc的返回值一定要强制类型转换；
		2. malloc申请的内存空间的内容不确定，一般需要使用memset进行清空；
		3. 调用malloc后，一定要判断一下，是否申请内存成功；
		4. 如果多次malloc申请的内存，第一次和第二次申请的内存不一定连续；

3.2 free函数 （释放内存函数）

函数说明：free函数释放ptr指向的内存
函数定义：void free(void *ptr)
注意事项：ptr指向的内存必须是malloc，calloc，relloc动态申请的内存

3.3 案例一：从堆区申请一个int类型的空间

[root@ansible9 ~]# cat  test.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(int arg, char *argv[])
{
	int *p=NULL;
	p=(int *)malloc((int)sizeof(int));
	if(p==NULL)
	{
		printf("malloc err\n");
		return 1;
	}
	printf("用malloc申请的内存空间中的内容是不确定的：%d\n",*p);
	memset(p,0,(int)sizeof(int));
	printf("用memset清0后的内存空间中的内容是：%d\n",*p);
	printf("请输入一个int数值：");
	scanf("%d",p);
	printf("%d\n",*p);
	free(p);
}
[root@ansible9 ~]# ./a.out 
用malloc申请的内存空间中的内容是不确定的：0
用memset清0后的内存空间中的内容是：0
请输入一个int数值：111
111

3.4 案例二：从堆区申请一个数组，数组的大小由用户决定

步骤：

  1. 从键盘获取要申请的数组的大小；
  2. 根据大小，从内存堆区申请空间；
  3. 对空间读写操作；
  4. 释放该空间；
[root@ansible9 ~]# cat test.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(int arg, char *argv[])
{
	printf("请输入数值元素的个数：");
	int n=0;
	scanf("%d",&n);
	printf("将要为元素个数为%d个的数组申请内存空间\n",n);
	int *p=NULL;
	p=(int *)malloc(n*(int)sizeof(int));
	if(p==NULL)
	{
		perror("malloc error!");
		return 1;
	}
	memset(p,0,n*(int)sizeof(int));
	int i=0;
	printf("请输入%d个int数组",n);
	for(i=0;i<n;i++)
	{
		scanf("%d",p+i);
	}
	for(i=0;i<n;i++)
	{
		printf("%d\n",p[i]);
	}
	free(p);
}
[root@ansible9 ~]# ./a.out 
请输入数值元素的个数：5
将要为元素个数为5个的数组申请内存空间
请输入5个int数组10 20 30 40 50 60 70 80 
10
20
30
40
50

3.5 calloc函数

函数原型：void * calloc(size_t nmemb, size_t size);
			参数： size_t是无符号整形，是在头文件中用typeof定义出来的
			返回值：申请失败：返回NULL；申请成功：返回申请的内存的首地址
函数功能：在内存的堆区，申请nmemb块，每块大小为size字节的连续内存空间
注意事项：
			1. calloc函数申请的内存空间已经自动被清0了，不用再用memset清0；
			2. calloc函数申请的内存空间字节数为nmemb和size的乘积；

[root@ansible9 ~]# cat test.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(int arg, char *argv[])
{
	printf("请输入数值元素的个数：");
	int n=0;
	scanf("%d",&n);
	printf("将要为元素个数为%d个的数组申请内存空间\n",n);
	int *p=NULL;
	p=(int *)calloc(n, (int)sizeof(int));
	if(p==NULL)
	{
		perror("calloc error!");
		return 1;
	}
	int i=0;
	printf("请输入%d个int数组",n);
	for(i=0;i<n;i++)
	{
		scanf("%d",p+i);
	}
	for(i=0;i<n;i++)
	{
		printf("%d\n",p[i]);
	}
	free(p);
}
[root@ansible9 ~]# ./a.out 
请输入数值元素的个数：5
将要为元素个数为5个的数组申请内存空间
请输入5个int数组10 20 30 40 50 60 70
10
20
30
40
50

3.5 realloc函数（重新申请内存空间）

函数原型：void* realloc(void* s, unsigned int newsize);
形参：s原先开辟内存的地址           newsize：新申请内存的大小
返回值：新申请内存的首地址
函数功能：在原先s执行的内存基础上重新申请内存，新的内存大小为newsize字节，如果原先内存后面有足够大的空间就追加；如果没有则realloc函数会在内存堆区找一个newsize字节大小的空间来申请，将原先内存中的数据拷贝过来，然后释放原先的内存，最后返回新内存的地址

[root@ansible9 ~]# cat test.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(int arg, char *argv[])
{
	printf("请输入数值元素的个数：");
	int n=0;
	scanf("%d",&n);
	printf("将要为元素个数为%d个的数组申请内存空间\n",n);
	int *p=NULL;
	p=(int *)calloc(n, (int)sizeof(int));
	if(p==NULL)
	{
		perror("calloc error!");
		return 1;
	}
	int i=0;
	printf("请输入%d个int数组元素",n);
	for(i=0;i<n;i++)
	{
		scanf("%d",p+i);
	}
	for(i=0;i<n;i++)
	{
		printf("%d\n",p[i]);
	}
	printf("想要为数组增加几个元素：");
	int m=0;
	scanf("%d",&m);
	printf("您想要增加%d个元素\n",m);
	p=(int *)realloc(p,(n+m)*(int)sizeof(int));
	if(p==NULL)
	{
		perror("calloc error!");
		return 1;
	}
	printf("请输入%d个新int数组元素",m);
	for(i=n;i<(m+n);i++)
	{
		scanf("%d",p+i);
	}
	for(i=0;i<(n+m);i++)
	{
		printf("%d\n",p[i]);
	}
	printf("数组现有%d个元素\n",(n+m));
	int h=0;
	printf ("想减少几个元素：");
	scanf("%d",&h);
	printf("您想减少%d个元素\n",h);
	p=(int *)realloc(p,(n+m-h)*(int)sizeof(int));
	if(p==NULL)
	{
		perror("calloc error!");
		return 1;
	}
	for(i=0;i<(n+m-h);i++)
	{
		printf("%d\n",p[i]);
	}
	free(p);
}
[root@ansible9 ~]# ./a.out 
请输入数值元素的个数：3
将要为元素个数为3个的数组申请内存空间
请输入3个int数组元素10 20 30
10
20
30
想要为数组增加几个元素：2
您想要增加2个元素
请输入2个新int数组元素40 50
10
20
30
40
50
数组现有5个元素
想减少几个元素：4
您想减少4个元素
10

四 动态内存申请的注意事项

4.1 指向堆区的指针变量不要随意更改指向，会导致calloc申请的内存空间泄漏

[root@ansible9 ~]# cat test.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(int arg, char *argv[])
{
	int *p = (int *)malloc(4*(int)sizeof(int));
	int num=10;
	p=&num;
}

4.2 不要操作已经释放的空间，因为该空间内容已经不能确定了

[root@ansible9 ~]# cat test.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(int arg, char *argv[])
{
	int *p = (int *)malloc((int)sizeof(int));
	memset(p,0,(int)sizeof(int));
	*p=100;
	free(p);
	printf("%d\n",*p);
}

4.3 不要对堆区空间重复释放

[root@ansible9 ~]# cat test.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(int arg, char *argv[])
{
	int *p = (int *)malloc((int)sizeof(int));
	memset(p,0,(int)sizeof(int));
	*p=100;
	free(p);
	free(p);
}
[root@ansible9 ~]# gcc -Wall test.c
[root@ansible9 ~]# ./a.out 
free(): double free detected in tcache 2
Aborted (core dumped)

4.4 如何防止对堆区空间重复释放？

在这里插入图片描述

五 从堆区中给各个数据类型申请内存空间

5.1 为int变量在堆区申请内存空间

int main(int arg, char *argv[])
{
        int *p = (int*)calloc(1,(int)sizeof(int));
        *p=100;
        printf("%d\n",*p);
        if(NULL!=p)
        {
                free(p);
                p=NULL;
        }
}

5.2 为char*变量在堆区申请内存空间

int main(int arg, char *argv[])
{
        char **p = (char**)calloc(1,(int)sizeof(char*));
        *p = (char*)calloc(1,(int)sizeof(char));
        printf("%p\n",p);
        printf("%p\n",*p);
        **p='A';
        printf("%c\n",**p);
}

5.3 为char数组变量在堆区申请内存空间

int main(int arg, char *argv[])
{
        char*p = (char*)calloc(5,(int)sizeof(char));
        int n=0;
        for(n=0;n<5;n++)
        {
                printf("请输入第%d个字符：",n+1);
                scanf("%c%*c",p+n);
        }
        printf("%s\n",p);
        free(p);
}

5.4 为结构体变量在堆区申请内存空间

struct stu
{
        int num;
        char name[32];
        int age;
};


int main(int arg, char *argv[])
{
        struct stu* p = (struct stu*)calloc(1,(int)sizeof(struct stu));
        p->num=100;
        strcpy(p->name,"andy");
        p->age=18;
        printf("num=%d\n",p->num);
        printf("name=%s\n",p->name);
        printf("age=%d\n",p->age);
}


struct stu
{
        int num;
        char name[32];
        int age;
};

void my_set_stu(struct stu* p)
{
        printf("请输入学生的信息 num name age\n");
        scanf("%d %s %d",&p->num,p->name,&(*p).age);
}
void my_print_stu(const struct stu* p)
{
        printf("num=%d\n",p->num);
        printf("name=%s\n",p->name);
        printf("age=%d\n",p->age);
}
int main(int arg, char *argv[])
{
        struct stu* p = (struct stu*)calloc(1,(int)sizeof(struct stu));
        my_set_stu(p);
        my_print_stu(p);
        free(p);
}

5.5 为结构体变量数组在堆区申请内存空间

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
struct stu 
{
	int num;
	char name[32];
	int age;
};

void my_set_stu(struct stu* p, int n)
{
	int i=0;
	for(i=0;i<n;i++)
	{
		printf("请输入第%d个学生的信息 num name age\n", i+1);
		scanf("%d %s %d",&(p+i)->num,(p+i)->name,&(*(p+i)).age);
	}
}
void my_print_stu(const struct stu* p, int n)
{
	int i=0;
	for(i=0;i<n;i++)
	{
		printf("第%d个学生的信息: ",i+1);
		printf("num=%d ",(p+i)->num);
		printf("name=%s ",(p+i)->name);
		printf("age=%d\n",(p+i)->age);
	}
}
int main(int arg, char *argv[])
{
	int n=0;
	printf("请输入学生个数：");
	scanf("%d",&n);
	struct stu* p = (struct stu*)calloc(n,(int)sizeof(struct stu));
	my_set_stu(p,n);
	my_print_stu(p,n);
	free(p);
}
qq_33808440
关注
  • 10
    点赞
  • 踩
  • 59
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C语言 ：学习动态内存分配
cainiaochufa2021的博客
02-27 1633
文章目录C语言动态分配为什么存在内存分配?动态内存函数的介绍`malloc``free``free`函数的**作用原理**是：使用后将指针赋为`NULL``calloc`运用一次`calloc`函数`realloc`当第一个参数为空指针时:当第一个参数不为空指针的时候:常见的动态内存分配错误对空指针的解引用操作对动态开辟空间的越界访问对非动态内存使用free释放对同一块动态内存进行多次释放忘记释放动态空间柔性数组柔性数组的特点一个如何开辟包含柔性数组成员的结构柔性数组的优势 C语言动态分配 为什么存在内存分
动态内存的申请
2301_81090045的博客
05-14 370
【代码】动态内存的申请。
C语言：动态内存管理
热门推荐
weixin_51142926的博客
01-17 1万+
学习数据结构之前，一定要对指针、结构体、动态内存管理进行深入学习！
C语言：动态分配内存
立于皓月之边，不弱星光之势
12-07 2591
2022-12-07（动态分配内存）
C语言:动态内存分配+经典面试题
须知少日拏云志，曾许人间第一流。
05-07 1641
通常，我们在栈空间开辟的内存都是固定的，这是十分不方便使用的。为了更加灵活的分配和使用内存，我们要学习C语言中一些常用的与内存分配相关联的函数。顺便，我们会补充数组中柔性数组的知识。
C语言基础教程_动态内存申请
m0_59519697的博客
04-30 5116
文章目录前言一、动态分配内存概述二、静态分配、动态分配2.1静态分配2.2动态分布三、动态分配函数3.1 malloc3.2 free3.3 calloc3.4 realloc四、内存泄漏总结 前言 本篇主要记录动态内存一些相关知识。 学习笔记，如有错误，还请指正。 码字不易，还请各位多多点赞收藏关注，感谢各位。 一、动态分配内存概述 在数组一文中，介绍过数组的长度是预先定义好的，在整个程序中固定不变，但是在实际的编程中，往往会发生这种情况，即所需的内存空间取决于实际输入的数据，而无法预先确定 。为了解
C语言：动态内存分配函数
2301_79268853的博客
07-01 915
动态内存分配是c语言中重要的内容，这是使用c语言实现诸多数据结构的基础之一。下面就来讲解一下主要的内存分配函数。以上就是c语言中动态内存分配函数的相关知识，希望对大家有所帮助。
C语言中动态申请内存的全部方式
l2020429的博客
08-23 896
C语言动态申请的内存的方式
c语言动态内存申请的作用,C语言动态内存申请
weixin_32237761的博客
05-16 684
原创coolmoying1月8日收录于话题#C语言零基础教程22个前言上一章节主要是介绍指针基础，了解指针操作数组，指针与函数的关系。本章节主要介绍C语言指针操作堆内存，简单来说就是动态内存申请。C语言动态内存申请在C语言中，当我们声明变量时，内存在栈的空间中分配。堆栈中分配的内存在编译时是固定的，一直保留到程序执行结束。创建数组时，必须在声明本身时指定大小，并且在程序执行期间不能更改该大小。...
C语言进阶：动态分配内存，二维指针
凯凯在此
04-03 1319
文章目录动态分配内存1.数组空间申请2.重新调整内存大小3. 数组的整体拷贝、比较、移动二维指针1. 二维指针的用法2. 动态内存创建二维数组 动态分配内存 1.数组空间申请 申请动态分配内存 malloc() stdlib.h 中定义函数 void* malloc(size_t size) 向系统申请大小为 size 的内存空间 返回结果是 void*，使用时转换成需要的指针类型 如果申请失败，返回 NULL 向系统申请一块 n*4 字节的空间 (int*)malloc(n*sizeof(int)) #i
C语言动态内存分配的详解
12-31
C语言动态内存分配的详解 1.为什么使用动态内存分配 数组在使用的时候可能造成内存浪费，使用动态内存分配可以解决这个问题。 2. malloc和free C函数库提供了两个函数，malloc和free，分别用于执行动态内存分配和...
C语言创建链表错误之通过指针参数申请动态内存实例分析
09-04
然而，通过指针参数申请动态内存是一个常见的错误点，这在给定的实例中得到了详细阐述。 首先，我们来看一下链表节点的定义： ```c typedef struct node{ int data; struct node* next; } Node; ``` 这里定义了一...
c语言中动态内存分配问题
10-19
在C语言中，动态内存分配是一项重要的编程技巧，它允许程序员在程序运行时根据需要分配内存，而不是在编译时预设固定的内存空间。本文将深入解析动态内存分配的细节和一个简单的C语言程序示例。 C语言提供了四个与...
c语言动态内存分配知识点及实例
08-24
C语言中的动态内存分配是程序运行时根据需要动态地申请和释放内存的一种机制。它允许程序员在不知道数据规模的情况下分配内存，从而提高了程序的灵活性。本文将深入探讨动态内存分配的关键知识点并提供实例。 1. **...
小型文件管理驱动，支持动态申请内存，释放内存，c语言实现
09-22
总的来说，这个项目提供了一个学习和理解C语言内存管理机制的实践平台，同时展示了如何在一个小型驱动中实现文件管理。开发者可以通过分析和修改这些源码，深入理解内存分配的内部工作原理，并提升对系统编程的理解...
C/C++基础知识
m0_67582670的博客
07-24 1635
3.signed char：有符号char（-128~127）2.unsigned char：无符号char（0~255）3.动态分配内存(malloc和new)1.静态分配，编译时在栈上分配好内存。4.自动分配，在局部函数中。1.char：标准类型。
JNDIExploit使用
07-29
一款用于 JNDI注入利用的工具，大量参考/引用了 Rogue JNDI项目的代码，支持直接植入内存shell，并集成了常见的bypass 高版本JDK的方式，适用于与自动化工具配合使用。 使用说明 使用 java -jar JNDIExploit.jar -h查看参数说明，其中 --ip参数为必选参数 Usage: java -jar JNDIExploit.jar [options] Options: * -i, --ip Local ip address -l, --ldapPort Ldap bind port (default: 1389) -p, --httpPort Http bind port (default: 8080) -u, --usage Show usage (default: false) -h, --help Show this help Dockerfile git clone https://github.com/feihong-cs/JNDIExploit.git cd ./JN
基于MATLAB的人体行为识别.zip
最新发布
07-29
在MATLAB中，可以使用机器学习和计算机视觉技术来实现人体行为识别。下面是一个基本的人体行为识别过程的程序： 1. 数据收集和准备： - 收集包含不同人体行为的视频数据。 - 使用视频处理技术提取每个视频中的人体姿势和关键点信息。 2. 特征提取： - 使用计算机视觉技术，如OpenPose或者其他姿势估计算法，提取每个视频中的人体关键点位置。 - 根据关键点位置计算特征向量，例如关节角度、运动速度等。 3. 数据标记和标签： - 根据人体行为类型，对收集的数据进行标记和分类，例如步行、跑步、打球等。 - 为每个人体行为类型分配一个标签。 4. 训练模型： - 使用机器学习算法，如支持向量机（SVM）、决策树、深度神经网络等，对标记和分类的数据进行训练。 - 使用训练数据和标签训练模型，以学习不同行为类型之间的关系。 5. 测试和识别： - 使用训练好的模型对新的测试数据进行预测和识别。 - 输入测试数据的特征向量到训练好的模型中，根据模型的输出来确定人体行为类型。 6. 评估和改进： - 根据测试结果评估
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值