【C语言】动态内存申请 | 内存区域的划分 | malloc、calloc、free函数的使用

最新推荐文章于 2023-09-26 17:09:18 发布
最新推荐文章于 2023-09-26 17:09:18 发布
阅读量921 收藏 4
点赞数 2
分类专栏： # C语言 文章标签： c语言 c++ 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MuShan_bit/article/details/122834317
版权

一 内存区域划分

1 代码区

存代码

2 常量区

存常量:数值常量 字符常量 字符串常量 符号常量(define) 地址常量…

3 全局区(静态全局区)

关键词:

  1. 静态变量(static) static:静态
  2. 全局变量
#include<stdio.h>

int b = 0;                 //普通全局变量
static int d = 0;          //静态全局变量

int main() {

	int a = 0;             //普通局部变量(主函数范围内)
	static int  c = 0;     //静态局部变量

	return 0;
}

作用与区别:

  1. 作用域 : 起作用的区域
  2. 生存周期(生命周期) : 起作用的时间段
#include<stdio.h>

//全局变量生存周期:程序开始到程序结束
int b = 0;                 //普通全局变量
	//普通全局变量作用域(项目作用域):作用域为整个项目,不同文件时用extern声明 
	//extern: extern + 完整定义
    //
static int d = 0;          //静态全局变量
	//静态全局变量作用域(文件作用域):作用域为当前文件

int main() {
	//作用域: 当前语块(变量定义到大括号结束)
	int a = 0;             //普通局部变量
	//生存周期:当前语块
	static int  c = 0;     //静态局部变量
	//生存周期:程序开始到程序结束

	return 0;
}

void  fun() {
	a = 10;               //报错:未定义标识符
	b = 10;
	c = 10;               //报错:未定义标识符
	d = 10;
	//a和c都为局部变量(作用域在变量定义到当前函数结束)
}

总结:

  1. 包含全局或静态的变量:生命周期皆为程序开始到程序结束,否则生命周期为当前语块(存储于静态全局区)
  2. 静态全局区:从程序开始系统自动分配内存,到程序结束系统自动回收内存
4 栈区

存储普通局部变量, 从定义开始系统自动分配内存,出了函数系统自动回收临时内存

5 堆区

由程序员手动申请,手动释放

二 void* 指针

空类型指针

#include<stdio.h>

int main() {
	void* p = NULL;
	p + 1; //错误:表达式必须是指向完整对象类型的指针
	p++;   //错误:表达式必须是指向完整对象类型的指针

	int* pn = NULL;
	pn = p;//错误:不能将"void*"类型的值分配到"int*"类型的实体
	p = pn;//正常执行

	short* psh = NULL;
	p = psh;

	*p;    //错误
	return 0;
}

1 不能偏移

2 不能自增自减

3 可以接受任意其他类型的指针

4 不能直接给其他类型的指针值(可以强转)

5 不能直接取内容

void*类型的指针不知道自己的长度(不完整)

三 动态申请内存

  1. 申请释放的方法

    头文件:

    #include<stdlib.h>

    申请

    void* malloc(size_t _Size);               // 参数:要在堆区申请的字节数
void* calloc(size_t _Count, size_t _Size);// 参数:类型长度, 个数

    释放

    void free(void* _Memory);                 // 参数:地址(释放内存的首地址)

    内存申请之后必须释放. 释放之后指针必须置空.

  2. 内存泄露和野指针

    内存泄露: 申请的内存没有进行释放

    野指针: 指针指向了不该指向的地方

  3. 简单应用举例

    1.1 使用malloc申请一个int类型大小的内存(4字节)

    	//1. 申请
	int* p = (int*)malloc(sizeof(int));//void* 给值要进行强转
	//2. 使用
	*p = 100;
	//3. 释放
	free(p);
	//4. 置空
	p = NULL;

    1.2 使用malloc申请十个int类型大小的内存(40字节)

    	//1. 申请
	int* p1 = (int*)malloc(sizeof(int) * 10);
	//2. 使用
	if (p1) { //未申请成功,函数返回NULL 由此判断是否申请成功
		//指针偏移使用
		p1[0] = 1;
		p1[2] = 10;
	}
	else printf("申请失败");
	//3. 释放
	free(p1);
	//4. 置空
	p1 = NULL;

    2.1 使用calloc申请一个int类型大小的内存(4字节)

    	//1. 申请
	int* p2 = (int*)calloc(sizeof(int), 1);
	//2. 使用
	*p2 = 100;
	//3. 释放
	free(p2);
	//4. 置空
	p2 = NULL;
    完整代码
    #include<stdio.h>
#include<stdlib.h>
int main() {
	//1.1 使用malloc申请一个int类型大小的内存(4字节)
	//1. 申请
	int* p = (int*)malloc(sizeof(int));//void* 给值要进行强转
	//2. 使用
	*p = 100;
	//3. 释放
	free(p);
	//4. 置空
	p = NULL;

	//1.2 使用malloc申请十个int类型大小的内存(40字节)
	//1. 申请
	int* p1 = (int*)malloc(sizeof(int) * 10);
	//2. 使用
	if (p1) { //未申请成功,函数返回NULL 由此判断是否申请成功
		//指针偏移使用
		p1[0] = 1;
		p1[2] = 10;
	}
	else printf("申请失败");
	//3. 释放
	free(p1);
	//4. 置空
	p1 = NULL;

	// 使用calloc申请一个int类型大小的内存(4字节)
	//1. 申请
	int* p2 = (int*)calloc(sizeof(int), 1);
	//2. 使用
	*p2 = 100;
	//3. 释放
	free(p2);
	//4. 置空
	p2 = NULL;
	return 0;
}
  4. 动态数组

    动态数组(并非数组,而是堆区申请的内存)

    类一维数组
    #include<stdio.h>
#include<stdlib.h>
int main() {

	//1. 申请
	int len = 10;
	int* arr = (int*)malloc(sizeof(int) * len);
	//2. 使用
	if (arr) { //未申请成功,函数返回NULL 由此判断是否申请成功
		//指针偏移使用
		for (size_t i = 0; i < len; i++) {
			arr[i] = i;
		}
		for (size_t i = 0; i < len; i++) {
			printf("%2d",arr[i]);
		}
		printf("\n");
	}
	else printf("申请失败");
	//3. 释放
	free(arr);
	//4. 置空
	arr = NULL;
	return 0;
}
    类二维数组
    #include<stdio.h>
#include<stdlib.h>
int main() {
	// 申请类似于int arr[3][4];
	//1.  申请
	//1.1 申请3个指针
	int** pp = (int**)calloc(sizeof(int*), 3); //函数参数用一级指针,函数应返回二级指针
	//1.2 分3次申请4个int大小的内存
	for (size_t i = 0; i < 3; i++) {
		pp[i] = (int*)calloc(sizeof(int), 4);
	}
	// ==> 不一定像真正的二维数组一样内存连续

	//2. 使用
	for (size_t i = 0; i < 3; i++) {
		for (size_t j = 0; j < 4; j++) {
			pp[i][j] = i * 10 + j;
			printf("%3d", pp[i][j]);
		}
		printf("\n");
	}
	printf("\n");
	//3. 释放
	free(pp);
	//4. 置空
	for (int i = 0; i < 3; i++) {
		pp[i] = NULL;
	}
	return 0;
}
    简单数组扩容

    思路:

    1. 给定默认长度

    2. 添加数据

    3. 如果装满了,自动扩容

    #include<stdio.h>
#include<stdlib.h>
int main() {
	// 1. 给定默认长度
	// 2. 添加数据
	// 3. 如果装满了,自动扩容

	// 默认初始长度:10
	int len = 10;

	// 申请长度为len(10)个int大小的内存
	int* p = (int*)calloc(sizeof(int), len);
	int* ptemp = p;       // 保存p当前地址

	int i = 0;            // 下标
	int num = 0;          // 用来接收每一次的输入

	// 添加数据(重复输入)_结束标志: -1
	while (scanf_s("%d", &num), num != -1) {
		// 1 长度足够
		if (i < len) {
			ptemp[i++] = num;
		}
		// 2 长度不够,需要扩容
		else {
			// 自定义扩容规则: 变为原来2倍
			len *= 2;
			p = (int*)calloc(sizeof(int), len);     //重新申请一段内存
			// 拷贝之前内存中的数据
			for (size_t j = 0; j < i; j++) {
				p[j] = ptemp[j];
			}
			p[i++] = num;      //添加当前需要添加的数据
			free(ptemp);
			ptemp = p;         //ptemp 重新指向新内存
		}
	}
	// 检验
	for (size_t j = 0; j < i; j++) {
		printf("%3d",ptemp[j]);
	}
	printf("\n当前内存长度:%d\n当前数据个数:%d\n",len,i);

	free(p);      //释放
	// p和ptemp为同一段内存,切勿重复释放
	p = ptemp = NULL;

	return 0;
}
MuShan-bit
关注
专栏目录
了解动态内存管理函数melloc、calloc、free、realloc，实现内存管理自由！
Rinne's blog
10-06 2204
动态内存管理 笔记自取链接：动态内存管理笔记 文章目录动态内存管理导言一、mallco 开辟动态内存空间二、free 释放动态内存空间三、calloc 初始化+开辟动态内存空间四、realloc 调整动态内存空间大小小结 导言 众所周知~，内存的分配如下图所示： 我们已经不满足于 int a = 0; int b[3] = 0; 这种变量占有固定的字节数，修改不了 我们比较熟悉的是静态区和栈区的变量类型，那么堆区里面有什么？ 接下来让我们一起了解一下动态内存分配类型的函数 一、mallco
C语言动态内存管理【malloc、calloc、realloc、free】
_featherbrain的博客
04-13 1395
动态内存管理目录🤔 前言 🤔📕 malloc 函数【动态内存开辟函数】 📕📗📘📙🌄 malloc 函数的声明 🌄🌅 malloc 函数的参数列表 🌅🌠 malloc 函数的返回类型 🌠⚓️ malloc 函数的使用注意事项⚓️ 🤔 前言 🤔 之前我们学会了在内存中开辟一块空间（也就是定义一个变量或数组），但是这些都是比较死板的。比如我们如果使用一个数组，当我们的需求量大于数组的空间时，数组空间远大于实际需求时，这个弊端就体现出来了。不太符合实际开发需求，在很多的在线OJ题目上也是要求使用动态内存来解题，这时
C语言的calloc使用
yanink的博客
04-20 1245
以前开发，使用内存方式，要么静态申请数组，要么使用malloc进行申请。 这次，要把原来实现的代码 static CACHE_DATA g_cache[MAX_CACHE_NUM] 修改为static CACHE_DATA *g_cache = NULL;的方式 也就是内存要动态申请了。 但是我其它的操作都是类似下面的操作：g_cache[g_cache_index].m_used = tru
用C语言编写一个申请内存的程序
zyqash的博客
04-24 3143
虚拟内存与实际内存 虚拟内存指的是，程序向操作系统所申请的内存空间，这个空间不一定会使用，这个空间也可以比服务器实际可提供内存空间大。 实际内存是程序所申请的内存页与物理内存中的物理页进行一一映射的内存空间，这个空间永远不会比物理内存大。 C语言内存空间分配函malloc()数简介. 调用形式： (类型说明符*)malloc(size) 功能：在内存的动态存储区中分配一块长度为“size”字节的连续区域。函数的返回值为该区域的首地址。 说明： （1）“类型说明符”表示把该区域用于何种数据类型。 （2
malloc函数、calloc函数和free函数
RosyCloudsLee的博客
03-14 331
转自：https://www.cnblogs.com/danielStudy/p/6583150.html 作者：Daniel_z malloc函数和free函数 malloc函数原型：void *malloc(long NumBytes) malloc原型说明：mallco函数在堆分配了NumBytes个字节的内存空间，用来存放数据，并返回了指向该内存的指针，如果分配失败，则会返...
C语言——动态内存管理 malloc、calloc、realloc、free的使用
weixin_50601177的博客
03-24 1321
动态内存管理
C语言--动态内存管理(malloc,free,calloc,realloc)
最新发布
2301_76618602的博客
09-26 125
但是上述的开辟空间的方式有两个特点：1. 空间开辟大小是固定的。2. 数组在申明的时候，必须指定数组的长度，它所需要的内存在编译时分配。但是对于空间的需求，不仅仅是上述的情况。有时候我们需要的空间大小在程序运行的时候才能知道， 那数组的编译时开辟空间的方式就不能满足了。这时候就只能试试动态存开辟了。
【C语言】动态内存函数（malloc, calloc, realloc, free）
codewinter的博客
07-26 550
【C语言学习之路】动态内存管理之动态内存函数 文章目录【C语言学习之路】动态内存管理之动态内存函数动态内存函数1）`malloc` 和 `free` 函数2）`calloc` 函数3）`realloc` 函数 本篇前言 我们之前学过的开辟空间的方式，开辟出来空间大小是固定的，往往在实际使用中，我们需要的空间大小在程序运行的时候才能知道，这个时候就需要使用到动态内存开辟了。 动态内存开辟是在内存的堆区开辟的。 ​ 动态内存函数 1）malloc 和 free 函数 malloc 函数： 向内存堆区申请一块
C语言中动态内存函数：malloc、calloc、realloc和free的干货
weixin_61941077的博客
09-28 2051
在我们平时写代码的过程中，程序员可能会有一种需求：那就是我们向内存空间申请大小的时候，如果能自己人为干预的条件下，就可使得空间的利用效率能够大大提高，而不是申请大了造成空间浪费，或者是申请小了不足以使用，下面给大家分享一种动态内存的存储原理，在有需要的时候可以试试动态内存开辟空间。
C语言中动态内存管理函数malloc(),calloc(),realloc(),free()函数及其常见使用错误详解
Cxz_learn_C的博客
09-28 647
C语言中动态内存管理函数malloc(),calloc(),realloc(),free()函数及其常见使用错误详解
C语言动态内存分配之malloc与realloc区别
01-20
　使用动态内存很明显的好处是：不需要预先分配存储空间且分配的空间可以根据程序的需要扩大或缩小，这样可以有效的使用内存空间。 　malloc和free 　C函数库中的malloc和free分别用于执行动态内存分配和释放。这...
C语言中calloc、malloc、free用法
夏之微风的博客
10-16 1429
前言 C语言中提供了一些内存管理函数，这些内存管理函数可以在程序运行期间分配内存空间，即可以动态地分配内存，也可以将已经分配的内存空间进行释放。常用的内存管理函数有 calloc、malloc、free三个函数。 calloc函数的功能是向系统申请分配连续的内存空间，如果申请获得成功，则把所分配内存区域的首地址作为函数值返回，该函数的返回值是void类型的指针；如果申请没有获得成功，则函数返回空指针。calloc函数的原型是void *calloc(unsigned n, unsigned size); 因
开辟内存new/malloc&作用域
post_joke的博客
01-10 972
c++中开辟内存用new关键字 如：int *p=new int; 释放内存 用delete 如delete p; new 的作用：1、开辟内存 2、初始化 3、开辟数组 4、释放数组 c++中开辟一维数组 如 int *cppp=new int[10] ;释放数组 delete []cppp; c语言中开辟一维数组：int *cp=(int *)malloc(sizeof(int)...
动态内存详解（malloc，calloc，realloc，free函数详解）
yosterv的博客
03-06 1106
malloc，calloc，realloc，free函数详解，动态内存详解
C语言学习笔记——（三）静态开辟内存和动态开辟内存
miyuexingchen的专栏
10-31 839
注：编码工具是CLion+Cygwin 目录 补充知识：C语言的布尔类型——非零即true。 静态开辟内存 静态开辟内存上限测试： 静态开辟内存特点： 静态开辟内存自动开辟和自动释放测试： 动态开辟内存 动态开辟内存特点： 动态开辟内存的使用场景： 动态开辟的内存未回收示例： 动态开辟的内存用完回收示例： realloc 补充知识：C语言的布尔类型——非零即true。 NULL==0。 #include <stdio.h> int main(){ i
手把手教你如何用malloc申请动态内存
weixin_44731936的博客
04-10 2272
前言 座右铭：talk is easy,show me the code. 我们生活在幸福的时代，我们都站在巨人的肩膀上看世界 手把手教你如何用malloc申请动态内存一点儿小故事为什么要申请动态内存？申请一维动态内存（连续的）动态申请二维数组（连续的）示例例题拓展 一点儿小故事 你有没有像我一样曾经这样申请内存： int **a=(int **)malloc(n*sizeof(int ));...
malloc()和free()的基本概念以及基本用法：
20164225的博客
04-08 613
一、malloc()和free()的基本概念以及基本用法： 1、函数原型及说明： void *malloc(long NumBytes)：该函数分配了NumBytes个字节，并返回了指向这块内存的指针。如果分配失败，则返回一个空指针（NULL）。 关于分配失败的原因，应该有多种，比如说空间不足就是一种。 void free(void *FirstByte)： 该函数是将之前用malloc分配的...
VS提示_Error：未定义标识符“malloc”
热门推荐
架构大师笔记
05-21 2万+
加上头文件 #include "malloc.h" OK！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

MuShan-bit

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

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

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

打赏作者

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

抵扣说明：

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

余额充值