C语言动态内存管理
1.存在动态内存分配的原因
已有的开辟内存的方式
int a=10;//在栈区开辟4个字节的空间
char arr[5]={0};//在栈空间开辟5个字节的空间
但上述开辟的内存空间有局限性:
1.开辟的空间大小是固定的
2.数组在声明的时候,必须指定数组的长度,它所需要的内存在编译时分配
但是我们有时需要根据实际情况来实时开辟内存,有些需要程序运行时才知道,所以需要动态内存管理。
内存分为栈区、堆区、静态区
2. malloc函数
2.1malloc函数介绍
两个函数的声明都在stdlib.h的头文件中
void *malloc( size_t size );
参数:无符号整数(size_t)类型的size,代表内存块的大小,单位是字节,比如size=40,就代表像内存开辟40个byte的空间
返回值:若成功开辟内存空间,返回指向函数分配的内存块的指针,若开辟失败,则返回一个空指针NULL,故需要对返回值进行检查
注意:1.由于malloc的返回值是void*,并没有指明具体的类型,所以使用者应该根据实际情况进行强制类型转换
2.新分配的内存块的内容未初始化
2.2malloc函数使用
#include<stdio.h>
#include <stdlib.h>
int main()
{
//动态内存开辟
int* p = (int*)malloc(10 * sizeof(int));//开辟40个字节的空间
if (p == NULL)
{
perror("main");
return 0;
}
int i = 0;
for (i = 0; i < 10; i++)//对开辟的内存空间赋初值
{
*(p + i) = i;
}
for (i = 0; i < 10; i++)
{
printf("%d ", p[i]);
}
free(p);
p = NULL;
return 0;
}
输出结果:
1.使用malloc函数需要的头文件是 #include <stdlib.h>
2.由于开辟的10个int的空间,所以需要使用int* 指针进行接收,方便以后解引用一次访问一个整型,并且强制类型转换成int*
3.malloc有可能开辟失败,所以需要对它的返回值进行判断
4.最后需要对开辟的内存进行释放
2.free函数
2.1free函数介绍
c语言提供了另一个函数free来对动态内存空间进行释放和回收的,总是与malloc成对出现
void free( void* memblock );
参数:指向先前使用或分配的内存块的指针
返回值:空
注意:1.该函数是解除已经分配的内存块的空间,如果不是上述分配的内存块的空间,会出现一些未定义的行为
2.如果参数是空指针,则不进行任何操作
2.2free函数的使用
free(p);
p = NULL;
1.该函数不是这样简单的使用,通常与malloc、calloc、realloc成对出现
2.该函数需要的头文件是 #include <stdlib.h>
根据2.2中的代码
经过free( p ) 后空间被释放,然后p指向空指针
3.calloc函数
3.1calloc函数介绍
void *calloc( size_t num, size_t size );
参数:无符号整数(size_t)类型的num,代表要分配的元素的数目,size代表每个元素的大小单位是字节,比如要开辟40个byte,则num=10,size=4
返回值:若成功开辟内存空间,返回指向函数分配的内存块的指针,若开辟失败,则返回一个空指针NULL,故需要对返回值进行检查
注意:1.由于calloc的返回值是void*,并没有指明具体的类型,所以使用者应该根据实际情况进行强制类型转换
2.新分配的内存块的内容默认初始化为0
3.2calloc函数的使用
#include<stdio.h>
#include <stdlib.h>
int main()
{
int* p = (int*)calloc(5, sizeof(int));
if (p == NULL)
{
perror("main");
}
int i = 0;
for (i = 0; i < 5; i++)
{
printf("%d ", *(p + i));//0 0 0 0 0
}
free(p);
p = NULL;
return 0;
}
输出结果:
4 realloc函数
4.1realloc函数介绍
realloc函数使得动态内存管理更加灵活,可以做到对动态开辟内存的大小的调整,为了合理的使用内存,我们一定会对内存的大小做灵活的调整,那么realloc 函数就可以做到对动态开辟内存大小的调整。
void *realloc( void* memblock, size_t size );
参数:memblock是要修改的内存空间的地址,size是内存块的新的大小,单位是字节
返回值:指向重新分配的内存块的指针,若空间够则要扩展内存就直接原有内存之后直接追加空间,原来空间的数据不发生变化。若不够,则在堆空间上另找一个合适大小的连续空间来使用。这样函数返回的是一个新的内存地址
注意:1.由于realloc的返回值是void*,并没有指明具体的类型,所以使用者应该根据实际情况进行强制类型转换
3.realloc() 对 ptr 指向的内存重新分配 size 大小的空间,size 可比原来的大或者小,还可以不变
4.2realloc函数的使用
#include<stdio.h>
#include <stdlib.h>
int main()
{
int* p = (int*)calloc(5, sizeof(int));
if (p == NULL)
{
perror("main");
}
int i = 0;
for (i = 0; i < 5; i++)
{
*(p + i) = i;
}
//扩容5个int
int* ptr = (int*)realloc(p, 20+5 * sizeof(int));//共40个字节,10个int
if (ptr != NULL)
{
p = ptr;
}
free(p);
p = NULL;
return 0;
}
realloc有可能找不到合适的空间来扩容,这时就返回NULL,因此需要一个临时变量来接收,防止p找不到原来的位置
5 C/C++程序的内存开辟
1.栈区(stack):函数内的局部变量的存储单元都可以在栈区上创建,函数结束时这些存储单元自动释放。栈区分配运算内置于处理器的指令集中,效率高,但是分配的内容有限。栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等
2.堆区(heap):一般由程序员分配释放,若程序员不释放,程序结束时可能由OS回收,分配方式类似于链表
3.数据段(静态区):static存放全局变量、静态数据,程序结束后由系统释放
4.代码段:存放函数体(类成员函数和全局函数)的二进制代码
6 柔性数组
C99 中,结构中的最后一个元素允许是未知大小的数组,这就叫做柔性数组成员
typedef struct st_type
{
int i;
int a[0];//柔性数组成员,有些编译器报错可改成int a[];
}type_a;
6.1柔性数组的特点
#include <stdio.h>
typedef struct st_type
{
int i;
int a[0];//柔性数组成员
}type_a;
int main()
{
printf("%d\n", sizeof(type_a));
return 0;
}
输出结果:
1.结构中的柔性数组成员前面必须至少一个其他成员
2.sizeof 返回的这种结构大小不包括柔性数组的内存
3.包含柔性数组成员的结构用malloc ()函数进行内存的动态分配,并且分配的内存应该大于结构的大小,以适应柔性数组的预期大小
6.2柔性数组的使用
#include <stdio.h>
#include <stdlib.h>
struct S
{
int i;
int arr[];
};
int main()
{ //开辟
struct S* ptr1 = (struct S*)malloc(sizeof(struct S) + 40);//4+40个字节
if (ptr1 == NULL)
{
perror("ptr1");
return 1;
}
//使用
ptr1->i = 10;
int i = 0;
for (i = 0; i < 10; i++)
{
ptr1->arr[i] = i;
}
for (i = 0; i < 10; i++)
{
printf("%d ", ptr1->arr[i]);
}
printf("\n");
//扩容
struct S* ptr2 = (struct S*)realloc(ptr1,sizeof(struct S) + 80);//4+40+40个字节
if (ptr2 != NULL)
{
ptr1 = ptr2;
}
//再使用
ptr1->i = 10;
for (i = 0; i < 20; i++)
{
ptr1->arr[i] = i;
}
for (i = 0; i < 20; i++)
{
printf("%d ", ptr1->arr[i]);
}
//释放
free(ptr1);
ptr1 = NULL;
return 0;
}
输出结果:
1.ptr2不需要释放,它和ptr1指向的地址一样,如果先把ptr2释放了,ptr1就成了野指针,只需释放ptr1即可
6.3柔性数组的优势
#include <stdio.h>
#include <stdlib.h>
struct S
{
int n;
int* arr;
};
int main()
{
//开辟
struct S* ps = (struct S*)malloc(sizeof(struct S));
if (ps == NULL)
{
return 1;
}
ps->n = 100;
ps->arr = (int*)malloc(40);
if (ps->arr == NULL)
{
perror("ps->arr");
return 1;
}
//使用
int i = 0;
for (i = 0; i < 10; i++)
{
ps->arr[i] = i;
}
for (i = 0; i < 10; i++)
{
printf("%d ", ps->arr[i]);
}
//扩容
int*ptr = (int*)realloc(ps->arr, 80);
if (ptr == NULL)
{
perror("ptr");
return 1;
}
//使用
//……
//释放
free(ps->arr);
free(ps);
ps = NULL;
return 0;
}
1.与6.2相比,此代码malloc两次,分别是结构体和arr*,也对应着free了两次,更容易出现内存泄露,内存碎片更多
2.为了控制变量,都在堆上开辟
优势1:方便内存释放
如果我们的代码是在一个给别人用的函数中,你在里面做了二次内存分配,并把整个结构体返回给用户。用户调用free可以释放结构体,但是用户并不知道这个结构体内的成员也需要free,所以你不能指望用户来发现这个事。所以,如果我们把结构体的内存以及其成员要的内存一次性分配好了,并返回给用户一个结构体指针,用户做一次free就可以把所有的内存也给释放掉。
优势2:这样有利于访问速度.
连续的内存有益于提高访问速度,也有益于减少内存碎片。