C语言 DAY10 内存分配

1.引入

int nums $10$ = {0}; //对
int len = 10;
int nums $len$ = {0}; //错
是因为系统的内存分配原则导致的

2.概述

在系统运行时，系统为了更好的管理进程中的内存，所以将内存进行了分配,其分配的机制就称为内存分配

1.静态分配原则

1.特点

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

2.动态分配原则

1.特点
1、在程序运行过程中，根据需要大小自由分配所需空间。
2、按需分配。
3、分配在堆区，一般使用特定的函数进行分配。
案例
班级有15个学员,定义数组记录学员成绩
double score $15$ = {0};
记录学员成绩
1,输入学员数量
2,在堆区申请
3,扩展
4,释放
注意
在 c 语言中提供了一系列动态分配内存的函数
这些函数大部分都在 stdlib.h 头文件中声明
free 释放
malloc 申请空间 , 默认值随机
calloc 申请空间 , 默认值为 0
realloc 扩展空间
string.h 中提供的函数
memset 将 malloc 中的随机数设为 0

3.动态内存分配

memset函数

作用：重置

语法：

#include <string.h>

void *memset = (void *s,int c,size_t n);

s:原指针

c:重置后的数据

n：重置的数量

从s开始,将n个字节的数据,设置为c

示例：
#include<stdio.h>
#include<string.h>
int main(int argc, char const *argv\[\])
{
char strs $10$ = {0};
memset(strs,'a',10*1);
for (int i = 0; i < 10; i++)
{
printf("%c ",strs $i$ );
}
printf("\n");
int nums $10$ = {1,2,3,4,5,6,7,8,9,10};
memset(nums,0,10 * 4);
for (int i = 0; i < 10; i++)
{
printf("%d ",nums $i$ );
}
printf("\n");
return 0;
}

free函数

作用：释放空间

语法：

#include<stdlib.h>

void free(指针变量名）;

malloc函数

作用：在堆中开辟一段内存空间

语法：

#include<stdlib.h>

void *malloc (size_t size);
参数:
size:开辟空间大小,单位字节,size_t可以理解为无符号int
返回值:
开辟的空间的地址
开辟失败返回NULL
注意:
1,在使用malloc需要判断是否开辟成功
2,如果多次 malloc 申请的内存，第 1 次和第 2 次申请的内存不一定是连续的
3,malloc的返回值在使用中记得强制类型转换
4,malloc从堆区申请空间后空间的内容中的值是随机的(与局部变量一样大概率为0),可以使用
memset函数对空间中的数据进行置
示例：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(int argc, char const *argv\[\])
{
//1, 申请空间
// 申请一个可以存储 10 个 int 数据的空间
int *p = (int *)malloc(10 * sizeof(int));
//2, 判断是否开辟失败
if (p == NULL)
{
printf("开辟失败 \n");
return 0;
}
// 置 0
memset(p,0,10 *sizeof(int));
//3, 使用空间
// for (int i = 0; i < 10; i++)
// {
// scanf("%d",&p $i$ );
// }
for (int i = 0; i < 10; i++)
{
printf("%d ",p $i$ );
}
printf("\n");
//4,释放空间
free(p);
return 0;
}

calloc函数

作用：在堆中开辟一段内存空间

语法：

#include <stdlib.h>

void *calloc(size_t nmemb, size_t size);
参数:
nmemb:申请的块数
size:每块的大小
返回值:
开辟的空间的地址
开辟失败返回NULL
int *p = malloc(10 * sizeof(int));
int *p = calloc(10,sizeof(int));

示例：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(int argc, char const *argv\[\])
{
//1, 申请空间
// 申请一个可以存储 10 个 int 数据的空间
// int *p = (int *)malloc(10 * sizeof(int));
int *p = (int *) calloc(10,sizeof(int));
//2, 判断是否开辟失败
if (p == NULL)
{
printf("开辟失败 \n");
return 0;
}
// 置 0
//memset(p,0,10 *sizeof(int));
//3, 使用空间
for (int i = 0; i < 10; i++)
{
scanf("%d",&p $i$ );
}
for (int i = 0; i < 10; i++)
{
printf("%d ",p $i$ );
}
printf("\n");
//4, 释放空间
free(p);
return 0;
}

realloc函数

作用：扩展空间

语法：

void *realloc(void *ptr, size_t size);
参数 :
ptr:原指针
size:从新开辟的大小 , 原大小 + 新开的大小
返回值 :
开辟成功返回新地址
开辟失败返回NULL
注意 :
新地址不一定等于原地址, 但是大概率相同
示例：
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char const *argv\[\])
{
int *p = (int *)calloc(3,sizeof(int));
int *p2 = (int *)calloc(3,sizeof(int));
//...
p = realloc(p,20);
for(int i = 0; i < 5; i++)
{
scanf("%d",&p $i$ );
}
for(int i = 0; i < 5; i++)
{
printf("%d,",p $i$ );
}
printf("\n");
free(p);
return 0;
}

4.内存泄露

概念：
申请的内存，首地址丢了，找不了，再也没法使用了，也没法释放了，这块内存就被泄
露了。
情况1： 记录申请的内存的指针变量指向别的地方
int *p = (int *)malloc(40);
int nums $10$ = {};
p = nums;
情况2： 在函数中申请空间 , 使用完毕没有释放
void test()
{
int *p = (int *)malloc(40);
}
test();
防止多次释放：
示例：
int *p = (int *)malloc(40);
free(p);
free(p);
//注意多次释放会报错
口诀 : 释放前判断 , 释放后置 NULL
int *p = (int *)malloc(40);
if(p != NULL)
{
free(p);
p = NULL;
}
if(p != NULL)
{
free(p);
p = NULL;
}