动态内存管理
目录
一、动态内存分配
二、动态内存函数
1.malloc 和 free
2.calloc
3.realloc
三、常见的动态内存错误
1.对NULL指针的解引操作
2.对动态开辟空间的越界访问
3.对非动态开辟内存使用free释放
4.使用free释放一块动态开辟内存的一部分
5.对同一块动态内存多次释放
6.动态开辟内存忘记释放（内存泄漏）
四、经典笔试题
五、C/C++程序的内存开辟
六、柔性数组
1.柔性数组的特点
2.柔性数组的使用
3.柔性数组的优势
一、动态内存分配
对于内存分配，我们之前已经学过在栈空间开辟的局部变量
如
int main()
{
int var = 20;//局部变量在栈空间开辟四个字节
char arr[10] = {0};//在栈空间开辟10个字节的连续空间
return 0;
}上述开辟空间的方式有两个特点：
- 空间开辟的大小是固定的
- 数组在声明的时候，必须指定数组的长度，它所需要的内存在编译时分配
但是如果只是这样，有时候我们需要的空间大小在程序运行的时候才能知道，那数组的编译时开辟空间的方式就不能满足了。这时就可以采取动态内存开辟。
二、动态内存函数
1.malloc 和 free
malloc函数
void* malloc (size_t size);该函数向内存申请一块连续可用的空间，并返回指向这块空间的指针
- 如果开辟成功，则返回一个指向开辟好空间的指针
- 如果开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做检查
- 返回值的类型是 void* ，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定
- 如果参数 size 为0，malloc的行为是标准是未定义的，取决于编译器
#include
#include
int main()
{
//申请一块空间，来存放5个整型
int* p = (int*)malloc(sizeof(int)*5);//因为mallc原返回类型是void*,这里要进行强制类型转化
if (p == NULL)
{
perror("malloc");//如果开辟失败会返回关于malloc的信息
return 1;
}
return 0;
} malloc 申请的空间是在内存堆区上申请的空间，而不是栈区上
如何使用malloc
#include
#include
int main()
{
//申请一块空间，来存放5个整型
int* p = (int*)malloc(sizeof(int)*5);//因为mallc原返回类型是void*,这里要进行强制类型转化
if (p == NULL)
{
perror("malloc");//如果开辟失败会返回关于malloc的信息
return 1;
}
//使用
int i = 0;
for (i = 0; i < 5;i++)
{
*(p+i) = i;
}
//打印
for (i = 0; i < 5; i++)
{
printf("%d ", * (p + i));
}
free(p);
p = NULL;
return 0;
} 
对于上述malloc开辟的空间，上述使用完后，是使用free进行释放的
关于malloc函数的释放
1. free 释放，这是一种主动释放 2. 程序退出后，malloc申请的空间也会被操作系统回收的(被动)
我们在写代码的正常情况下，谁申请的空间，谁去释放; 万一自己没有释放，也要交代给别人，记得释放，避免内存泄漏。
free函数
C语言提供了另外一个函数free，专门是用来做动态内存的释放和回收的
void free (void* ptr);free函数用来释放动态开辟的内存
- 如果参数 ptr 指向的空间不是动态开辟的，那free函数的行为是未定义的
- 如果参数 ptr 是NULL指针，则函数什么事都不做
注意: 使用 malloc 和 free 要引用头文件 stdlib.h
2.calloc
calloc也是用来开辟内存空间的
void* calloc (size_t num, size_t size);
我们发现calloc 与malloc 很像
就比如 申请10个整型的空间
calloc(10,sizeof(int));而上方的malloc
malloc(10*sizeof(int));除了参数的区别，还有
函数的功能是为 num 个大小为 size 的元素开辟一块空间，并且把空间的每个字节初始化为0
calloc 函数的使用
//calloc内存函数的使用
#include
#include
int main()
{
//动态分配5个整型空间
int* p = (int *)calloc(5,sizeof(int));//动态分配并初始化空间，元素置零
if (p == NULL)
{
perror("calloc");//如果动态分配失败，打印关于calloc的错误信息
}
int i = 0;
//打印元素的值
for (i = 0; i < 5;i++)
{
printf("%d",*(p+i));
}
printf("\n");
//元素赋值
for (i = 0; i < 5;i++)
{
*(p + i) = i;
//二次打印
printf("%d",*(p+i));
}
//使用free 函数进行空间释放，避免内存泄露
free(p);
p = NULL;//记得置为空
return 0;
}
所以当我们需要 动态分配内存空间并且需要初始化，使用calloc是一种很好的选择
3.realloc
void* realloc (void* ptr, size_t size);对于动态内存函数realloc函数更加灵活
有时我们使用malloc和calloc函数进行动态内存分配的时候,我们发现所分配的空间已经固定下来，那木我们就会想 会不会有一种可以调整动态内存大小的动态分配的内存函数呢？接下里就就是我们介绍的realloc内存函数，可以对动态内存空间进行重新调整大小。
- ptr 是要调整的内存地址
- size 调整之后新大小
- 返回值为调整之后的内存起始位置
- 这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到 新 的空间
- realloc在调整内存空间的是存在两种情况
情况1
情况2
realloc函数的使用
//使用calloc 开辟空间，使用realloc调整空间
#include
#include
int main()
{
//比如开辟5个整型空间
int* p = (int*)calloc(5,sizeof(int));
if (p == NULL)
{
perror("calloc");
return 1;
}
int i = 0;
for (i = 0; i < 5;i++)
{
*(p + i) = i;
}
//这里希望调整为10个整型的空间
int* ptr = (int*)realloc(p,10*sizeof(int));
if (ptr != NULL)
{
p = ptr;//如果开辟成功，p指向ptr
}
//给后续的5个空间赋值
for (i = 5; i < 10; i++)
{
*(p + i) = i;
}
//打印
for (i = 0; i < 10; i++)
{
printf("%d ",* (p + i));
}
free(p);
p = NULL;
return 0;
} 注意 如果realloc的第一个参数为NULL 就等价于 malloc
realloc(NULL,10*sizeof(int)) == malloc(10*sizeof(int))
三、常见的动态内存错误
1.对NULL指针的解引操作
//对NULL指针的解引操作
int main()
{
int* p = (int*)malloc(40);
//没有对返回值判断，可能开辟内存失败，就使用了NULL指针，解引用
*p = 20;
free(p);
return 0;
}这里的改正应该是加上对空指针的判断语句
int main()
{
int* p = (int*)malloc(40);
if (p== NULL)
{
;
//.....
}
*p = 20;
free(p);
return 0;
}2.对动态开辟空间的越界访问
#include
#include
int main()
{
int* p = (int*)malloc(5 * sizeof(int));
if (p == NULL)
{
perror("malloc");
return 1;
}
int i = 0;
for (i = 0; i <= 5;i++)//注意这里的等于号，越界访问了
{
*(p + i) = i;
}
free(p);
p = NULL;
return 0;
} 
即使是动态内存函数开辟的空间，也是不能越界访问的
3.对非动态开辟内存使用free释放
void test()
{
int a = 10;
int *p = &a;
free(p);//这样是错误的
}4.使用free释放一块动态开辟内存的一部分
//使用free释放一块动态开辟内存的 一部分
void test()
{
int* p = (int*)malloc(100);
p++;
free(p);//注意这里是释放部分动态开辟的内存
}5.对同一块动态内存多次释放
void test()
{
int* p = (int*)malloc(100);
free(p);
//...
free(p);//重复释放是不对的
}6.动态开辟内存忘记释放（内存泄漏）
void test()
{
int* p = (int*)malloc(100);
if (p != NULL)
{
*p = 20;
}
}
int main()
{
test();
//..
return 0;
}忘记释放不再使用的动态开辟的空间会造成内存泄漏
动态开辟的空间一定要释放，并且正确释放
四、经典笔试题
分析下方代码
题1
//题1
#include
#include
#include
void GetMemory(char* p)
{
p = (char*)malloc(100);
}
void Test(void)
{
char* str = NULL;
GetMemory(str);
strcpy(str,"hello word");
printf(str);
}
int main()
{
Test();
return 0;
} 解析
代码改正
#include
#include
#include
void GetMemory(char** p)
{
*p = (char*)malloc(100);//*p找到外面的str
}
void Test(void)
{
char* str = NULL;
GetMemory(&str);//要想获取修改后的str,这里要把str的地址传过去
strcpy(str, "hello word");//这时str指向存放100个字节的空间,然后把字符串拷贝过去
printf(str);//打印
//释放空间
free(NULL);
str = NULL;
}
int main()
{
Test();
return 0;
} 修改方法二
#include
#include
#include
char* GetMemory()
{
char *p = (char*)malloc(100);
return p;//返回p
}
void Test(void)
{
char* str = NULL;
str = GetMemory();
strcpy(str, "hello word");//这时str指向存放100个字节的空间,然后把字符串拷贝过去
printf(str);//打印
//释放空间
free(NULL);
str = NULL;
}
int main()
{
Test();
return 0;
} 题2
//题二
#include
#include
char* GetMemory()
{
char p[] = "hello world";
return p;
}
void Test()
{
char* str = NULL;
str = GetMemory();
printf(str);
}
int main()
{
Test();
return 0;
} 解析
题3
//题3
#include
#include
#include
void GetMemory(char**p, int num)
{
*p = (char*)malloc(num);
}
int main()
{
char* str = NULL;
GetMemory(&str,100);
strcpy(str,"hell0");
printf(str);
return 0;
} 解析
少了free(存在内存泄漏问题)
题4
//题4
void Test()
{
char* str = (char*)malloc(100);
strcpy(str,"hello");
free(str);
if (str != NULL)
{
strcpy(str,"word");
printf(str);
}
}
int main()
{
Test();
return 0;
}解析
五、C/C++程序的内存开辟
在C/C++中，内存的开辟可以使用以下方法：
1. 静态内存分配：在编译时就分配好内存空间，例如定义全局变量和静态变量时所使用的内存就是静态内存。静态内存的特点是不需要程序员手动释放，但是分配的内存大小在编译时就已经确定，有一定的局限性。
2. 栈内存分配：在函数内部定义的局部变量所使用的内存就是栈内存，函数执行时自动分配内存，函数退出时自动释放内存。栈内存的特点是速度快，但分配的内存大小有限，可能会导致栈溢出。
3. 堆内存分配：使用动态内存分配函数（如malloc、new等）在堆中分配内存，程序员手动申请和释放内存。堆内存的特点是使用灵活，但需要程序员手动释放内存，否则会导致内存泄漏。
实际上普通的局部变量是在栈区分配空间的，栈区的特点是在上面创建的变量出了作用域就销毁。
但是被static修饰的变量存放在数据段（静态区），数据段的特点是在上面创建的变量，直到程序
结束才销毁
所以生命周期变长
六、柔性数组
柔性数组（Flexible Array）是一种特殊的数组类型，在定义数组时可以不指定其长度，而是通过程序运行时动态地分配数组空间
struct flex_array {
size_t len;
int data[]; // 柔性数组，未知大小的数组
};
其中，data就是柔性数组，它的长度可以在程序运行时动态调整，而len则记录了数组当前的长度。在使用柔性数组时，通常需要使用动态内存分配函数（如malloc、calloc等）来为其分配空间，同时也需要注意在使用完毕后及时释放内存，以避免内存泄漏等问题
1.柔性数组的特点
- 结构中的柔性数组成员前面必须至少一个其他成员
- sizeof 返回的这种结构大小不包括柔性数组的内存
- 包含柔性数组成员的结构用malloc ()函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小
2.柔性数组的使用
#include
#include
struct S
{
char c;
int i;
int arr[];
};
int main()
{
struct S* ps = (struct S*)malloc(sizeof(struct S)+20);
if (ps == NULL)
{
perror("malloc");
return 1;
}
ps->c = 'w';
ps->i = 100;
int i = 0;
for (i = 0; i < 5;i++)
{
ps->arr[i] = i;
}
//打印
for (i = 0; i < 5;i++)
{
printf("%d ",ps->arr[i]);
}
printf("%c %d",ps->c,ps->i);
//当空间不够用就使用realloc 继续增加
struct S* ptr = (struct S*)realloc(ps,sizeof(struct S*)+40);
if (ptr == NULL)
{
perror("realloc");
return 1;
}
free(ps);
ps = NULL;
return 0;
} 3.柔性数组的优势
方便内存释放：
如果我们的代码是在一个给别人用的函数中，你在里面做了二次内存分配，并把整个结构体返回给
用户。用户调用free可以释放结构体，但是用户并不知道这个结构体内的成员也需要free，所以你
不能指望用户来发现这个事。所以，如果我们把结构体的内存以及其成员要的内存一次性分配好
了，并返回给用户一个结构体指针，用户做一次free就可以把所有的内存也给释放掉
有利于提高访问速度：
连续的内存有益于提高访问速度，也有益于减少内存碎片。