C语言基础教程_动态内存申请_创建100字节的内存空间-CSDN博客

本文链接：https://blog.csdn.net/m0_59519697/article/details/124508176

文章目录

前言
一、动态分配内存概述
二、静态分配、动态分配
- 2.1静态分配
- 2.2动态分布
三、动态分配函数
四、内存泄漏
总结

前言

本篇主要记录动态内存一些相关知识。
学习笔记，如有错误，还请指正。
码字不易，还请各位多多点赞收藏关注，感谢各位。

一、动态分配内存概述

在数组一文中，介绍过数组的长度是预先定义好的，在整个程序中固定不变，但是在实际的编程中，往往会发生这种情况，即所需的内存空间取决于实际输入的数据，而无法预先确定。为了解决上述问题，Ｃ语言提供了一些内存管理函数，这些内存管理函数可以按需要动态的分配内存空间，也可把不再使用的空间回收再次利用。

动态分配内存就是在堆区开辟空间

二、静态分配、动态分配

2.1静态分配

1）在程序编译或者运行过程中，按照事先规定大小分配内存空间的分配方式。int a[10]
2）事先需要知道所需要空间大小
3）分配在栈区或者全局变量区，一般以数组形式
4）按照计划分配

2.2动态分布

1）在程序运行中，按照需要大小分配空间
2）按需分配
3）分配在堆区，一般使用特定的函数进行分配

三、动态分配函数

3.1 malloc

#include<stdlib.h>
void *malloc(unsigned int size);
//功能：在堆区开辟指定长度的空间，并且空间是连续的
//参数：size： 要开辟空间的大小
//返回值：成功：开辟好的空间首地址
//			失败：NULL

注意：
1）在调用malloc之后，要进行判断，是否申请内存成功。
2）多次使用malloc申请的内存，第一次和第二次申请的内存不一定是连续的。
3）使用malloc开辟空间需要保存好空间的首地址，但是由于不确定空间是用于干什么，所以使用返回值类型为void * ，所以在调用函数时根据接受者的类型对其进行强制类型转化

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

char *fun()
{
    //char ch[100] = "hello world";

    //静态全局区的空间只要开辟好，除非程序结束，否则不会释放，所以
    //如果是临时使用，不建议使用静态全局区的空间
    //static char ch[100] = "hello world";

    //堆区开辟空间，手动申请手动释放，更加灵活
    //使用malloc函数的时候一般要进行强转
    char *str = (char *)malloc(100 * sizeof(char));
    str[0] = 'h';
    str[1] = 'e';
    str[2] = 'l';
    str[3] = 'l';
    str[4] = 'o';
    str[5] = '\0';

    return str;
}

int main(int argc, char *argv[])
{
    char *p;
    p = fun();
    printf("p = %s\n", p);

    //使用free函数释放空间
    free(p);
    //防止野指针
    p = NULL;

    return 0;
}

执行结果：
在这里插入图片描述

3.2 free

#include<stdlib>
void free(void *prt)
//功能：释放堆区的空间
//参数: prt：开辟后使用完毕的堆区空间的首地址
//返回值：无

注意：
1）free函数只能释放堆区的空间，其他区域无法使用free
2）free释放空间必须释放malloc或者calloc的返回值对应的空间，不能只释放一部分
3）free( p ); 当free后，因为没有给p赋值，所以p还是指向原先动态申请的内存，但是内存已经不能在使用了，p就变成了野指针，所以一般free完毕之后对p赋值为NULL
4）一块儿动态申请的内存只能free一次，不能free多次。

3.3 calloc

#include<stdlib.h>
void * calloc(size_t nmemb,size_t size)
// 功能： 在堆区申请指定大小的空间
// 参数：		nmemb：要申请空间的块儿数
//				size：每块的字节数
//返回值：	成功：申请空间的首地址
//				失败：NULL

char *p = (char *)calloc(3,100);
在队中申请了3块，每块大小为100个字节，一共申请了300个字节连续的空间。

注意：
malloc和calloc函数都是用来申请内存的。
区别：
1）函数名字不同
2）参数个数不同
3）malloc申请的内存，内存中存放的内容是随机的，不确定的
而calloc函数申请的内存中内容为0

3.4 realloc

#include<stdlib.h>
void* realloc(void *s，unsigned int newsize);

//功能：在原本申请好的堆区空间的基础上重新申请内存，新的空间大小为函数的第二个参数
//如果原本申请好的空间的后面不足以增加指定的大小，系统会重新找一个足够大的位置开辟指定的空间，然后将原本空间中的数据拷贝过来，然后释放原本的空间如果newsize比原先的内存小，则会释放原先内存的后面的存储空间，只留前面的newsize个字节
//参数：
//		s：原本开辟好的空间的首地址
//		newsize：重新开辟的空间的大小
//返回值：
//		新的空间的首地址

增加空间：

char *p;
// 申请100个字节
p = (char *)malloc(100);
// 追加50个字节
p = (char *)realloc(p,150)	//p指向的内存的新的大小为150个字节

在这里插入图片描述

减少空间：

char *p;
// 申请100个字节
p = (char *)malloc(100);
// 减少50个字节
p = (char *)realloc(p,50)	//p指向的内存的新的大小为50个字节，其中后面50个字节的空间就被释放了

注意：
malloc calloc realloc 动态申请的内存，只有在free或程序结束的时候才释放

四、内存泄漏

内存泄漏：
申请的内存，首地址丢失，找不到，再也没办法使用，无法释放，这块儿内存就泄露了

案例一：

int main()
{
	char *p;
	p=(char *)malloc(100);
//接下来，可以用p指向的内存了
	p="hello world";//p指向别的地方了，保存字符串常量的首地址
//从此以后，再也找不到你申请的100个字节了。则动态申请的100个字节就被泄露了
	return 0;
}

案例二：

void fun()
{
	char *p;
	p=(char *)malloc(100);
//接下来，可以用p指向的内存了
...
}

int main()
{
//每调用一次fun泄露100个字节
	fun();
	fun();
	return 0;
}

解决方法一：

void fun()
{
	char *p;
	p=(char *)malloc(100);
	//接下来，可以用p指向的内存了
	...
	free(p);
}

int main()
{
	fun();
	fun();
	return 0;
}

解决方法2：

char * fun()
{
	char *p;
	p=(char *)malloc(100);
	//接下来，可以用p指向的内存了
	...
	return p;
}

int main()
{
	char *q;
	q=fun();
	//可以通过q使用 ，动态申请的100个字节的内存了
	//记得释放
	free(q);
	//防止野指针
	q = NULL;

	return 0;
}