目录
- 1.malloc和free函数
-
- [1.1 malloc函数](#1.1 malloc函数)
- [1.2 free函数](#1.2 free函数)
- [1.3 malloc函数的使用](#1.3 malloc函数的使用)
- 2.calloc函数
-
- [2.1 calloc函数](#2.1 calloc函数)
- [2.2 calloc函数的使用](#2.2 calloc函数的使用)
- 3.realloc函数
-
- [3.1 realloc函数](#3.1 realloc函数)
- [3.2 realloc函数的使用](#3.2 realloc函数的使用)
- 4.动态内存管理笔试题
-
- [4.1 笔试题（1）](#4.1 笔试题（1）)
- [4.2 笔试题（2）](#4.2 笔试题（2）)
- 5.柔性数组
-
- [5.1 柔性数组定义](#5.1 柔性数组定义)
- [5.2 柔性数组的使用](#5.2 柔性数组的使用)
1.malloc和free函数
1.1 malloc函数
malloc函数的功能是向内存申请一块连续的内存空间，并将内容初始化为随机值，申请的大小是参数size，单位是字节,返回类型是void*类型的指针。
malloc函数的返回值：如果申请成功，会返回申请的内存空间起始位置的地址，如果申请失败会返回NULL（空指针）.
1.2 free函数
free函数的功能是将开辟的内存空间释放，参数是开辟内存空间的起始地址，释放后参数ptr并不为NULL（空指针），因此使用free函数释放内存空间的同时，需要将ptr置为空指针；如果ptr本身为NULL，free函数不会执行。
1.3 malloc函数的使用
c
#include<stdio.h>
#include<stdlib.h>
//malloc函数的使用
int main()
{
//开辟十个整型的空间大小
//需要类型转换为int*类型的指针作为返回值
int* ptr = (int*)malloc(10 * sizeof(int));
//判断是否为NULL指针
if (ptr == NULL)
{
//输出错误原因
perror("malloc");
return 1;//终止程序
}
//使用for循环初始化
int i = 0;
for (i = 0; i < 10; i++)
{
ptr[i] = i + 1;
}
//输出打印
for (i = 0; i < 10; i++)
{
printf("%d ", ptr[i]);
}
//释放内存空间
free(ptr);
ptr = NULL;//赋值为空指针
return 0;
}按F10启动调试观察malloc函数空间的开辟和释放的过程：观察开辟后内存空间的值
使用for循环初始化后的内容
输出初始化的内容1-10
按F10观察执行free函数后，开辟内存空间的内容，以及参数的变化
在使用free函数后需要及时将参数ptr置为空指针，否则会导致非法访问内存空间，导致程序奔溃。
2.calloc函数
2.1 calloc函数
calloc函数的功能与malloc一样，向内存申请一块连续的内存空间；与malloc函数不同的是，calloc函数有两个参数，第一个参数是元素个数，第二个参数是一个元素的大小，单位是字节，返回值是void*类型的指针。
如果开辟成功，返回开辟空间的起始地址，开辟失败，返回NULL（空指针）。
2.2 calloc函数的使用
c
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#pragma warning(disable:4996)//strcpy在VS中可能报警告，提示不安全，
//使用此指令可以不报警告，安全使用strcpy函数
//calloc的使用
struct Stu
{
char name[20];//名字
int age;//年龄
float score[3];//成绩
};
int main()
{
//开辟1个结构体大小
//需要类型转换为struct Stu*类型的指针作为返回值
struct Stu* ptr = (struct Stu*)malloc(1 * sizeof(struct Stu));
//第一个参数元素个数，第二个元素一个元素大小
//判断是否为NULL指针
if (ptr == NULL)
{
//输出错误原因
perror("calloc");
return 1;//终止程序
}
float score1[3] = { 90.00f,85.50f,99.00f };
//初始化
strcpy((ptr->name,"Mary");//ptr->name表示name成员首元素地址
ptr->age = 20;
memcpy(ptr->score, score1,sizeof(score1));//ptr->score表示score成员首元素地址
//输出打印
printf(" name: %s\n age: %d\n score: %.2f %.2f %.2f",
ptr->name, ptr->age, ptr->score[0], ptr->score[1], ptr->score[2]);
//释放内存空间
free(ptr);
ptr = NULL;//赋值为空指针
return 0;
}按F10启动调试，观察calloc函数使用后内存空间的变化：使用calloc函数后，内存空间开辟成功，将内容初始化为随机值或者0。
初始化后
输出
free函数释放空间后，将参数置为空指针
3.realloc函数
3.1 realloc函数
realloc函数的功能是当开辟的内存空间不够或者多余时，进行内存空间的调整；第一个参数是调整空间的起始地址，第二个参数是调整后内存空间的大小，返回值是void*类型的指针。
如果开辟成功有两种情况，第一种是在原有的基础上，后面追加调整补充的空间，返回第一个参数的地址；第二种是重新开辟一块新的内存空间，将开辟的内存空间的起始地址返回；如果开辟失败返回空指针。
3.2 realloc函数的使用
c
#include<stdio.h>
#include<stdlib.h>
int main()
{
//使用calloc开辟5个整型大小
int* ptr = (int*)calloc(5, sizeof(int));
//判断是否开辟失败
if (ptr == NULL)
{
perror("calloc");//输出错误内容
return 1;
}
//调整为6个整型大小
int* ptr1 = (int*)realloc(ptr, 6 * sizeof(int));
if (ptr1 == NULL)
{
//1.将原开辟的空间释放，并置空指针
free(ptr);
ptr = NULL;
//2.输出错误信息
perror("realloc");
return 1;//终止程序
}
//释放内存空间，并置空指针
free(ptr1);
ptr1 = NULL;
return 0;
}按F10启动调试观察使用realloc函数后的内容变化：调用calloc函数后的内容
观察调用realloc函数后的内容
最后将空间释放，回收内存空间，最后不free(ptr)是因为，realloc函数在重新开辟新空间时，会将原有的参数开辟的空间释放，最后就不用再次释放，只需要释放调整后的内存空间。
4.动态内存管理笔试题
4.1 笔试题（1）
c
//以下程序的运行结果是什么？
#include <stdio.h>
#include <stdlib.h>
void GetMemory(char* p)
{
p = (char*)malloc(100);
}
void Test(void)
{
char* str = NULL;
GetMemory(str);
strcpy(str, "hello world");
printf(str);
}
int main()
{
Test();
return 0;
}
c
程序运行的结果是程序崩溃，因为GetMemory函数传参str,使用char*p接收，p变量是str的一份临时拷贝，
改变形参不能改变实参的值，所以在调用strcpy函数函数时，str是NULL,导致程序终止。4.2 笔试题（2）
c
//以下程序的运行结果是什么？存在什么问题？
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
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,但是开辟内存空间后没有的释放内存空间，导致内存泄露。
5.柔性数组
5.1 柔性数组定义
柔性数组是存在于结构体中的最后一个成员，使用柔性数组的结构体必须至少包含两个成员，如下：
c
struct S
{
int i;
int arr[0];//柔性数组
};sizeof计算时不会包含柔性数组的大小。
c
#include<stdio.h>
struct S
{
int a;
char ch[0];//柔性数组
};
int main()
{
printf("%zu", sizeof(struct S));
return 0;
}
5.2 柔性数组的使用
c
#include<stdlib.h>
struct Peo//人的结构体
{
char name[20];//名字
int age;//年龄
char adress[20];//通讯地址
char tele[12];//联系方式
};
struct Contact//通讯录
{
int count;//当前存储信息数量
int capacity;//当前容量
struct Peo data[0];//柔性数组（结构体数组）
};
int main()
{
//开辟空间:一个整型和十个struct Peo大小
struct Contact* ptr = (struct Contact*)malloc(sizeof(int) + 10 * sizeof(struct Peo));
//判断
if (ptr == 0)
{
perror("malloc");
return 1;
}
//使用
//......
//......
//调整(内存空间不足时，根据count和capacity的值进行调整）
//......
//......
//释放空间
free(ptr);
ptr = NULL;
return 0;
}柔性数组使用的好处：
1.灵活的内存管理：柔性数组允许结构体的最后一个成员是一个未知大小的数组。这意味着在动态分配内存时，可以根据实际需求来改变数组的长度，从而实现了内存的灵活管理。
2.提高访问速度：由于柔性数组直接作为结构体的一个成员，访问时不需要通过指针进行间接访问，这减少了访存次数，提高了访问速度。
3.减少内存碎片：通过动态分配内存，柔性数组可以更有效地利用内存空间，减少内存碎片的产生。