目录
A.前言:
C语言最重要的是指针,结构体,动态内存管理,这篇博客主要分享动态内存管理以及相关例题
这里是cool fire,希望这篇博客对你有所帮助
B.为什么存在动态内存分配
目前我们主要通过定义数据类型比如int,short,char……和数组来申请内存
要求写一个通讯录,如果只使用定义数据类型和数组来实现所有函数,最终的通讯录是静态的(见10.14博客),如果通讯录的存储的人数是变化的,那么通讯录就会发生空间不够或空间浪费的问题(假如只存20人,通讯录却有能存100人的数据的空间,浪费了80人的数据的内存空间)
如果我们想要存20人的数据要求通讯录就只有20人的空间大小,当添加或删减时通讯录大小自动随之变化,以及其他类似的问题,要实现就要用到动态内存分配
C.动态内存函数的介绍
1.malloc
Allocates memory blocks.
void *malloc( size_t size );
Routine | Required Header |
malloc | <stdlib.h> and <malloc.h> |
1.malloc只负责开辟内存,不关心内存要存放的的数据类型,所以返回的是void*类型的指针,使用时常将malloc强制类型转换为所需要的数据类型
2.当使用malloc要开辟对于全部内存来说是很大的空间时,会开辟失败,这时malloc会返回空指针
所以为了防止malloc返回空指针,我们在使用malloc函数时要在其后添加if判断,如果malloc为空指针,返回值设为1(正常情况下返回值是0),则判定返回值异常结束程序运行,如果malloc返回值不为空指针则程序继续运行
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
//malloc函数所需要的头文件
#include<errno.h>
//errno需要的头文件
#include<string.h>
//strerror需要的头文件
int main()
{
int* p = (int*)malloc(40);
if (p == NULL)
{
printf("%s\n", strerror(errno));
//把错误码转换成错误信息打印出来
return 1;
}
//使用
int i = 0;
for (i = 0; i < 10; i++)
{
*(p + i) = i;
}
for (i = 0; i < 10; i++)
{
printf("%d ",*(p+i));
}
return 0;
}
结果并没有报错
如果要求malloc开辟最大整数(INT_MAX)个字节空间,程序会报错
INT_MAX
define定义的最大整型常量(约21亿)
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
//malloc函数所需要的头文件
#include<errno.h>
//errno需要的头文件
#include<string.h>
//strerror需要的头文件
int main()
{
int* p = (int*)malloc(INT_MAX);
if (p == NULL)
{
printf("%s\n", strerror(errno));
//把错误码转换成错误信息打印出来
return 1;
}
//使用
int i = 0;
for (i = 0; i < 10; i++)
{
*(p + i) = i;
}
for (i = 0; i < 10; i++)
{
printf("%d ",*(p+i));
}
return 0;
}
使用malloc函数后要释放空间,否则会造成内存泄漏,释放内存空间需要使用free操作,但是上面的代码没有使用free释放空间,是否会造成内存泄漏呢?
内存泄漏:程序运行完后,没有归还内存空间,但是程序又不使用这片内存空间,程序即不还也不使用这片内存空间,其他程序也无法使用,相当于这片内存空间丢失,也就是内存泄漏
解答:没有free并不是说内存空间不回收了,当程序日退出的时候系统会自动回收内存空间
对于局部变量和形式参数是放在栈区的,malloc,calloc,realloc,free里的数据是放在堆区的
栈区的数据是静态的,堆区的数据存放是动态的
为了更加严谨,我们添加了free
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
//malloc函数所需要的头文件
#include<errno.h>
//errno需要的头文件
#include<string.h>
//strerror需要的头文件
int main()
{
int* p = (int*)malloc(40);
if (p == NULL)
{
printf("%s\n", strerror(errno));
//把错误码转换成错误信息打印出来
return 1;
}
//使用
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;
//防止意外的访问p,使p成为野指针
return 0;
}
为什么free了指针p后(也就是说归还了malloc函数开辟的空间),还要赋空指针给p
解答:因为malloc函数即使归还了开辟的空间,但是指针p仍然指向以前的地址,如果意外访问了指针p,由于已经归还了开辟的空间,所以访问p的地址时,p会成为野指针,程序会报错,所以这里给p赋空指针,防止p被意外访问
在free后,p仍然指向以前的地址,访问p会使p成为野指针
p,10可以访问指针p+i的其余元素
注意:
不能写成free(p=NULL),应该先释放空间,再取地址为空
如果先取地址为空,那么free就找不到要释放的空间,无法释放malloc开辟的空间
2.free
free函数是用来释放动态开辟的内存
1.如果参数ptr指向的空间不是动态开辟的,那么free函数的行为是未定义的
2.如果参数ptr是NULL指针,则函数什么事都不做
解释1:
直接使用free函数释放了栈区的空间,程序会报错
int main()
{
int a = 10;
int* p = &a;
free(p);
p = NULL;
return 0;
}
解释2:
如果传给free函数的是空指针,free不知道要释放什么空间,free什么都不做
int main()
{
int *p = NULL;
free(p);
retrun 0;
}
3.calloc
Allocates an array in memory with elements initialized to 0.
void *calloc( size_t num, size_t size );
Routine | Required Header |
calloc | <stdlib.h> and <malloc.h> |
int main()
{
int* p = (int*)calloc(10, sizeof(int));
if (p == NULL)
{
printf("%s\n", strerror(errno));
return 1;
}
int i = 0;
for (i = 0; i < 10; i++)
{
printf("%d ", *(p + i));
}
free(p);
p = NULL;
return 0;
}
说明calloc在开辟好10个大小为4字节的空间后,会将这10个整型数据初始化为0
想初始化就用calloc,不初始化空间就用malloc
4.realloc
realloc函数的出现让动态内存管理更加灵活
有时我们会发现过去申请的空间太小了,有时候我们又会觉得申请的空间过大了,那为了合理的使用内存,我们一定会对内存的大小做灵活的调整,那realloc函数就可以做到对动态开辟内存大小的调整
Reallocate memory blocks.
void *realloc( void *memblock, size_t size );
Routine | Required Header |
realloc | <stdlib.h> and <malloc.h> |
传进要改变大小的空间的地址,传入新的大小(假若原来有40个字节,要扩容40个字节,那么总共就是80字节,这里要传入80)
int main()
{
int* p = (int*)malloc(40);
if (*p == NULL)
{
printf("%s\n", strerror(errno));
return 1;
}
//使用
int i = 0;
for (i = 0; i < 10; i++)
{
*(p + i) = i + 1;
}
//扩容
//扩容40个字节,总共有80个字节,这个是新的大小
realloc(p, 80);
return 0;
}
那么realloc是如何在内存扩容的呢?
情况1:
情况2:
情况2中旧地址realloc找到新地址,就会把旧地址的空间释放掉
5.通讯录动态增长版本
test.c
#define _CRT_SECURE_NO_WARNINGS
#define _CRT_SECURE_NO_WARNINGS
#include "contact(dynamic).h"
enum Option
{
EXIT,
ADD,
DEL,
SEARCH,
MODIFY,
SHOW,
SORT,
};
void menu()
{
printf("*********************************************************\n");
printf("************* 1.add 2.del ***************\n");
printf("************* 3.search 4.modify **************\n");
printf("************* 5.show 6.sort ***************\n");
printf("************* 0.exit ***************\n");
printf("*********************************************************\n");
}
int main()
{
int input = 0;
Contact con;//创建了通讯录变量
//初始化通讯录
InitContact(&con);
do
{
menu();
printf("请选择:");
scanf("%d", &input);
switch (input)
{
case ADD:
AddContact(&con);
break;
case DEL:
DelContact(&con);
break;
case SEARCH:
SearchContact(&con);
break;
case MODIFY:
ModifyContact(&con);
break;
case SHOW:
ShowContact(&con);
break;
case SORT:
SortContact(&con);
break;
case EXIT:
//在使用完malloc和calloc函数后要在退出程序时回收空间
DestroyContact(&con);
printf("退出通讯录\n");
break;
default:
printf("输入错误\n");
break;
}
} while (input);
return 0;
}
contact.c
#define _CRT_SECURE_NO_WARNINGS
#define _CRT_SECURE_NO_WARNINGS
#include "contact(dynamic).h"
//静态版本初始化
//void InitContact(Contact* pc)
//{
// assert(pc);
// pc->count = 0;
// memset(pc->data, 0, sizeof(pc->data));
//}
//动态版本初始化
int InitContact(Contact* pc)
{
assert(pc);
pc->count = 0;
//开辟三个PeoInfo类型的空间,并初始化
pc->data = (PeoInfo*)calloc(DEFAULT_SZ ,sizeof(PeoInfo));
if (pc->data == NULL)
{
printf("InitContact::%s\n", strerror(errno));
return 1;
}
pc->capacity = DEFAULT_SZ;
return 0;
}
void DestroyContact(Contact* pc)
{
assert(pc);
free(pc->data);
pc->data = NULL;
}
//静态版本
//void AddContact(Contact* pc)
//{
// assert(pc);
// if (pc->count == MAX)
// {
// printf("通讯录已满,无法添加\n");
// return;
// }
// printf("请输入名字:");
// scanf("%s", pc->data[pc->count].name);
// printf("请输入年龄:");
// scanf("%d", &(pc->data[pc->count].age));
// printf("请输入性别:");
// scanf("%s", pc->data[pc->count].sex);
// printf("请输入电话:");
// scanf("%s", pc->data[pc->count].tele);
// printf("请输入地址:");
// scanf("%s", pc->data[pc->count].addr);
//
// pc->count++;
// printf("增加成功\n");
//}
//增容函数
void CheckCapacity(Contact* pc)
{
if (pc->count == pc->capacity)
{
PeoInfo* ptr = (PeoInfo*)realloc(pc->data, (pc->capacity + INC_SZ) * sizeof(PeoInfo));
if (ptr == NULL)
{
printf("AddContact::%s\n", strerror(errno));
//在报错信息前指明是哪里报错了
return;
//报错就返回
}
else
{
pc->data = ptr;
pc->capacity += INC_SZ;
printf("增容成功\n");
}
}
}
//动态版本
void AddContact(Contact* pc)
{
assert(pc);
//检测要不要增容,要增容就增容,不要增容就走一遍跳出
CheckCapacity(pc);
//
printf("请输入名字:");
scanf("%s", pc->data[pc->count].name);
printf("请输入年龄:");
scanf("%d", &(pc->data[pc->count].age));
printf("请输入性别:");
scanf("%s", pc->data[pc->count].sex);
printf("请输入电话:");
scanf("%s", pc->data[pc->count].tele);
printf("请输入地址:");
scanf("%s", pc->data[pc->count].addr);
pc->count++;
printf("增加成功\n");
}
void ShowContact(const Contact* pc)
{
assert(pc);
printf("%20s\t%5s\t%5s\t%12s\t%30s\n", "名字", "年龄", "性别", "电话", "地址");
//一个汉字是两个字节,所以这里的年龄项用了%5s,为了保持对齐,下面也用了%5d
//想要左对齐在百分号后面加负号
int i = 0;
for (i = 0; i < pc->count; i++)
{
printf("%20s\t%5d\t%5s\t%12s\t%30s\n", pc->data[i].name,
pc->data[i].age,
pc->data[i].sex,
pc->data[i].tele,
pc->data[i].addr);
}
}
//添加了static的代码只能在.c源文件看到
static int FindByName(Contact* pc, char name[])
{
assert(pc);
int i = 0;
for (i = 0; i < pc->count; i++)
{
if (0 == strcmp(pc->data[i].name, name))
{
return i;
}
}
return -1;
}
void DelContact(Contact* pc)
{
char name[MAX_NAME] = { 0 };
assert(pc);
int i = 0;
if (pc->count == 0)
{
printf("通讯录为空,没有信息可以删除\n");
return;
}
printf("请输入要删除人的名字:>");
scanf("%s", name);
//删除
//1.查找
int pos = FindByName(pc, name);
if (pos == -1)
{
printf("要找的人不存在\n");
return;
}
//2.删除
for (i = pos; i < pc->count - 1; i++)
{
pc->data[i] = pc->data[i + 1];
//拿后面的元素依次覆盖前面的元素
}
pc->count--;
//覆盖后,也就相当于删除了一个人的信息
//如果要删除最后一个人的信息,直接count--,因为访问函数是通过count的值来完成访问的
//count--之后的count作了最大值,也就无法访问count--之前的count的值,从而达到删除最后一个的信息的目的
//要结合前面的ShowContact函数理解
printf("删除成功\n");
}
void SearchContact(Contact* pc)
{
assert(pc);
char name[MAX_NAME] = { 0 };
printf("请输入要查找的人的名字:>");
scanf("%s", name);
//查找
int pos = FindByName(pc, name);
if (pos == -1)
{
printf("要查找的人不存在\n");
return;
}
//打印
else
{
printf("%20s\t%5s\t%5s\t%12s\t%30s\n", "名字", "年龄", "性别", "电话", "地址");
//一个汉字是两个字节,所以这里的年龄项用了%5s,为了保持对齐,下面也用了%5d
//想要左对齐在百分号后面加负号
printf("%20s\t%5d\t%5s\t%12s\t%30s\n", pc->data[pos].name,
pc->data[pos].age,
pc->data[pos].sex,
pc->data[pos].tele,
pc->data[pos].addr);
}
}
void ModifyContact(Contact* pc)
{
assert(pc);
char name[MAX_NAME] = { 0 };
printf("请输入要修改的人的名字:>");
scanf("%s", name);
//1.查找
int pos = FindByName(pc, name);
if (pos == -1)
{
printf("要修改的人不存在\n");
return;
}
//2.修改
else
{
printf("要修改的人已找到,请修改信息\n");
printf("请输入名字:");
scanf("%s", pc->data[pos].name);
printf("请输入年龄:");
scanf("%d", &(pc->data[pos].age));
printf("请输入性别:");
scanf("%s", pc->data[pos].sex);
printf("请输入电话:");
scanf("%s", pc->data[pos].tele);
printf("请输入地址:");
scanf("%s", pc->data[pos].addr);
printf("修改成功\n");
}
}
static int cmp_peo_by_name(const void* e1, const void* e2)
{
return strcmp(((PeoInfo*)e1)->name, ((PeoInfo*)e2)->name);
}
//按照名字来排序
void SortContact(Contact* pc)
{
assert(pc);
//起始位置,比较的成员个数,每个成员的大小
qsort(pc->data, pc->count, sizeof(PeoInfo), cmp_peo_by_name);
printf("排序成功\n");
}
contact.h
#pragma once
#include<string.h>
#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
#define MAX 100
#define MAX_NAME 20
#define MAX_SEX 10
#define MAX_TELE 12
#define MAX_ADDR 30
#define DEFAULT_SZ 3
#define INC_SZ 2
//类型的声明
//人的信息
typedef struct PeoInfo
{
char name[MAX_NAME];
int age;
char sex[MAX_SEX];
char tele[MAX_TELE];
char addr[MAX_ADDR];
}PeoInfo;
//加了typedef重命名类型struct PeoInfo
//通讯录
typedef struct Contact
{
PeoInfo* data;//存放人的信息
int count;//记录当前通讯录中实际人的个数
//记录当前通讯录的容量
//初始能存放三个人的数据,之后每次扩容增加两个人的数据容量
//当count=容量的值时,增容
int capacity;
}Contact;
//对初始化通讯录的函数的声明
int InitContact(Contact* pc);
//传的是Contact类型的地址,所以声明的就是Contact类型的指针
//对销毁通讯录的函数的声明
void DestroyContact(Contact* pc);
//对增加联系人的通讯录的函数的声明
void AddContact(Contact* pc);
//对打印通讯录中的信息的函数的声明
void ShowContact(const Contact* pc);
//对删除通讯录中的信息的函数的声明
void DelContact(Contact* pc);
//对查找指定联系人的函数进行声明
void SearchContact(Contact* pc);
//对修改指定联系人信息的函数进行声明
void ModifyContact(Contact* pc);
//对排序通讯录中的内容的函数进行声明
//按照名字来排序
//按照年龄来排序
//……
void SortContact(Contact* pc);
D.常见的动态内存错误
1.对NULL指针的解引用操作
对空指针的解引用操作会使程序报错
为了避免这个问题,我们在开辟空间后要做一次判断,判断开辟的地址是否为空指针
使用完开辟的空间后,要使用free释放内存,为了防止意外访问,在释放空间后把开辟空间的地址赋值为空指针
以上就构成了完整的逻辑
int main()
{
int* p = (int*)malloc(40);
//
//if(p == NULL)
//{
// printf("%s\n",strerror(errno));
// return 1;
// }
//
*p = 20;
//这个代码存在潜在的隐患,万一*p是空指针,程序就会报错
//所以在调用malloc函数后要判断malloc是否为空指针
//free(p);
//p = NULL;
return 0;
}
2.对动态开辟空间的越界访问
int main()
{
int* p = (int*)malloc(40);
if (p == NULL)
{
printf("%s\n",strerror(errno));
return 1;
}
//方式
int i = 0;
for (i = 0; i <= 10; i++)
{
p[i] = i;
}
free(p);
p = NULL;
return 0;
}
如果对动态开辟空间越界访问,程序会报错,如上,报错图我就不放了
3.对非动态开辟内存使用free释放
void test()
{
int a = 10;
int *p = &a;
//free(p);
//p = NULL;
return 0;
}
没错,程序会报错
4.使用free释放一块动态开辟内存的一部分
int main()
{
int* p = (int*)malloc(40);
if (p == NULL)
{
printf("%s\n", strerror(errno));
return 1;
}
//使用
int i = 0;
for (i = 0; i < 10; i++)
{
*p = i;
p++;
}
//释放,malloc函数开辟的空间没有全部释放
free(p);
p = NULL;
return 0;
}
没错会报错
5.对同一块动态内存多次释放
int main()
{
int* p = (int*)malloc(40);
if (p == NULL)
{
printf("%s\n", strerror(errno));
return 1;
}
free(p);
//如果释放空间后把p赋为空指针,再次free就不会报错
//如果在释放空间后没有把malloc开辟的空间地址赋为空指针,再次free就会报错
//p = NULL;
free(p);
return 0;
}
没错会报错
6.动态开辟内存忘记释放(内存泄漏)
情况1:
void test()
{
int* p = (int*)malloc(100);
int flag = 0;
scanf("%d\n", &flag);
if (flag == 5)
return;
//程序在这里return返回,不会执行剩下的代码
free(p);
p = NULL;
}
int main()
{
test();
return 0;
}
这里就会造成内存泄漏
情况2:
int* test()
{
int* p = (int*)malloc(100);
if (p == NULL)
{
return p;
}
return p;
}
int main()
{
int* ret = test();
//在调用函数后,没有将函数开辟的空间释放
return 0;
}
由函数开辟的空间忘记释放
E.几个经典的笔试题
类型:返回栈空间的地址的问题
例1.调用Test函数后会有什么结果
void GetMemory(char* p)
{
p = (char*)malloc(100);
}
void Test(void)
{
char* str = NULL;
//str指向空指针,但是str的地址并不为空
GetMemory(str);
//这里传入了str的值,即空指针
//在函数里执行就是malloc开辟了100个字节的大小空间赋值给了空指针
//但是由于p是形式参数,出了函数就被销毁,而且p开辟的空间未被回收会造成空间泄漏
//所以strcpy里传入仍然为空指针
//strcpy无法把hello world拷贝到空指针,程序会崩溃
strcpy(str, "Hello World");
printf(str);
}
int main()
{
Test();
return 0;
}
不会打印Hello World
会造成局部变量p指向的空间丢失,造成空间泄漏
str是NULL,在解引时会造成程序崩溃
改正1:
void GetMemory(char* *p)
{
*p = (char*)malloc(100);
}
void Test(void)
{
char* str = NULL;
GetMemory(&str);
//把str的地址传给GetMemory
//str存放的是动态开辟的100个字节的地址
strcpy(str, "Hello World");
printf(str);
//释放
free(str);
str = NULL;
}
int main()
{
Test();
return 0;
}
改正2:
char* GetMemory()
{
char* p = (char*)malloc(100);
return p;
}
//开辟空间
void Test(void)
{
char* str = NULL;
str = GetMemory();
strcpy(str,"Hello World");
printf(str);
free(str);
str = NULL;
}
//赋值
int main()
{
Test();
return 0;
}
//完成调用
例2:
char* GetMemory(void)
{
char p[] = "hello world";
return p;//返回了hello world的首地址
}
void Test(void)
{
char* str = NULL;
str = GetMemory();
//这里传入了p指针,但是p指针指向的空间已经被回收
//也就是说局部变量p在最后只传递出了hello world的首地址,但是首地址指向的hello world所在的空间在函数调用结束后就被系统回收了,再次调用这个首地址去寻找hello world,这个指针就变成了野指针
printf(str);
//如果调用str,str就会变成野指针
}
int main()
{
Test();
return 0;
}
例3:
void GetMemory(char** p, int num)
{
*p = (char*)malloc(num);
}
void Test(void)
{
char* str = NULL;
GetMemory(&str, 100);
strcpy(str, "hello");
printf(str);
}
int main()
{
Test();
return 0;
}
会打印hello
这个代码的缺点是调用函数结束后没有释放malloc开辟的空间
例4:
void Test(void)
{
char* str = (char*)malloc(100);
strcpy(str, "hello");
free(str);
if (str != NULL)
{
strcpy(str, "world");
//这里的str的空间已经释放,再次使用str去拷贝数据,这里的str就是野指针,造成了非法访问,程序会报错
printf(str);
}
}
int main()
{
Test();
return 0;
}
改正:
void Test(void)
{
char* str = (char*)malloc(100);
strcpy(str, "hello");
free(str);
str = NULL;
if (str != NULL)
{
strcpy(str, "world");
printf(str);
}
}
int main()
{
Test();
return 0;
}
F.c或c++的内存开辟
G.柔性数组
也许你从来没有听过柔性数组这个概念,但是它确实存在。C99中,结构中的最后一个元素允许是未知大小的数组,这就叫做【柔性数组】成员。
例如:
typedef struct st_type
{
int i;
int a[0];
}type_a;
有些编译器会报错无法编译可以改成:
typedef struct st_type
{
int i;
int a[];//柔性数组成员
}type_a;
1.柔性数组的特点
结构中的柔性数组成员前面必须至少有一个其他成员
struct S
{
int n;
int arr[];//柔性数组成员
};
sizeof返回的这种结构大小不包括柔性数组的内存
struct S
{
int n;
int arr[];//柔性数组成员
};
int main()
{
int sz = sizeof(struct S);
printf("%d\n", sz);
return 0;
}
可以看到没有计算后面数组的大小
包含柔性数组成员的结构用malloc()函数进行内存的动态分配,并且分配的内存应该大于结构的大小,以适应柔性数组的预期大小
struct S
{
int n;
int arr[];//柔性数组成员
};
int main()
{
int sz = sizeof(struct S);
printf("%d\n", sz);
struct S s;
return 0;
}
如果直接使用结构体去创建结构体变量,那么结构体变量不会为柔性数组开辟空间,这里只会为整型变量n开辟空间
那么如何使用结构体内部的柔性数组呢,我们需要结合malloc函数使用
struct S
{
int n;
int arr[];//柔性数组成员
};
int main()
{
//int sz = sizeof(struct S);
//printf("%d\n", sz);
//struct S s;
struct S* ps = (struct S*)malloc(sizeof(struct S) + 40);
return 0;
}
使用malloc为结构体开辟空间,此时开辟的空间不包含柔性数组的空间,再+40作为为柔性数组开辟的空间
当前代码的内存布局:
2.柔性数组的使用
struct S
{
int n;
int arr[];//柔性数组成员
};
int main()
{
//int sz = sizeof(struct S);
//printf("%d\n", sz);
//struct S s;
struct S* ps = (struct S*)malloc(sizeof(struct S) + 40);
if(ps == NULL)
{
printf("%s\n",strerror(errno));
return 1;
}
ps->n = 100;
int i = 0;
for (i = 0; i < 10; i++)
{
ps->arr[i] = i;
}
for (i = 0; i < 10; i++)
{
printf("%d ", (ps->arr[i]));
}
return 0;
}
那么柔性数组的柔性体现在哪里?
这个柔性数组可以通过malloc来调整大小,这里体现了柔性
struct S
{
int n;
int arr[];//柔性数组成员
};
int main()
{
//int sz = sizeof(struct S);
//printf("%d\n", sz);
//struct S s;
struct S* ps = (struct S*)malloc(sizeof(struct S) + 40);
if (ps == NULL)
{
printf("%s\n", strerror(errno));
return 1;
}
ps->n = 100;
int i = 0;
for (i = 0; i < 10; i++)
{
ps->arr[i] = i;
}
for (i = 0; i < 10; i++)
{
printf("%d ", (ps->arr[i]));
}
//扩容
struct S* ptr = (struct S*)realloc(ps, sizeof(struct S) + 80);
if (ptr != NULL)
{
ps = ptr;
ptr = NULL;
}
//释放
free(ps);
ps = NULL;
return 0;
}
3.利用指针实现类似柔性数组的功能
struct S
{
int n;
int* arr;
};
int main()
{
struct S* ps = (struct S*)malloc(sizeof(struct S));
//先把这个结构体存放在malloc开辟的空间里
//因为我们的指针需要指向一个可变的数组,所以需要将结构体存放在堆里
if (ps == NULL)
{
printf("%s\n",strerror(errno));
return 1;
}
ps->n = 100;
ps->arr = (int*)malloc(40);
if (ps->arr == NULL)
{
printf("%s\n",strerror(errno));
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)
{
ps = ptr;
ptr = NULL;
}
else
return 1;
//释放
free(ps->arr);
free(ps);
ps = NULL;
return 0;
}
当前代码的内存布局:
4.比较两种方式
方式一更优,因为方式一使用malloc一次性开辟了所需的空间,free也只需一次就释放了目标空间,减少了碎片化空间,提高空间使用率
连续的内存有利于提高访问速度,所以使用柔性数组提高了访问速度
方式二,需要两次malloc去开辟所需要的空间,造成了空间碎片化,需要两次free释放空间,
降低访问速度
总结:
所以最好的话在结构体内使用柔性数组,避免使用结构体内指针指向malloc开辟的空间这种做法
H.结语:
以上就是动态内存管理的内容了,看到这里真的很厉害,请加油
人海茫茫,相遇不易,这里是冷色调的火
我们下次再见