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函数的使用

#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函数的使用

#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函数的使用

#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）

//以下程序的运行结果是什么？
#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;
}

程序运行的结果是程序崩溃，因为GetMemory函数传参str,使用char*p接收，p变量是str的一份临时拷贝，
改变形参不能改变实参的值，所以在调用strcpy函数函数时，str是NULL,导致程序终止。

4.2 笔试题（2）

//以下程序的运行结果是什么？存在什么问题？
#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 柔性数组定义

柔性数组是存在于结构体中的最后一个成员，使用柔性数组的结构体必须至少包含两个成员，如下：

struct S
{int i;int arr[0];//柔性数组
};

sizeof计算时不会包含柔性数组的大小。

#include<stdio.h>
struct S
{int a;char ch[0];//柔性数组
};int main()
{printf("%zu", sizeof(struct S));return 0;
}

5.2 柔性数组的使用

#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.减少内存碎片‌：通过动态分配内存，柔性数组可以更有效地利用内存空间，减少内存碎片的产生‌。