目录
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.结语：
以上就是动态内存管理的内容了，看到这里真的很厉害，请加油
人海茫茫，相遇不易，这里是冷色调的火
我们下次再见
1943
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
