? ? ? ?
? ? ? ?我们都知道平常的局部变量和函数形式参数实在栈区开辟的，但这个时候其内存所开辟空间的大小是固定的，而且所需要的内存在编译时分配，但很多时候我们所需要的空间大小在程序运行的时候才能知道，这个时候我们就只能试试动态内存开辟了。
目录
1.动态内存函数的介绍
1.1 malloc和free
void* malloc (size_t size);malloc函数的使用方法
这个函数向内存申请一块连续可用的空间，并返回指向这块空间的指针。
如果开辟成功，则返回一个指向开辟好空间的指针。
如果开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做检查。
返回值的类型是void*，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定。
如果参数size为0，malloc的行为是标准是未定义的，取决于编译器。
C语言提供了另外一个函数free，专门是用来做动态内存的释放和回收
#include <stdlib.h>
int main()
{
int arr[10] = { 0 };
int* p = (int *)malloc(40);//申请空间
if (p == NULL)
{
return -1;
}
//开辟成功了
int i = 0;
for (i = 0; i < 10; i++)
{
*(p + i) = i;
}
free(p);
p=NULL;
return 0;//p必须置为空，否则变成危险的野指针
}
free(p);
1.2 calloc函数
void* calloc (size_t num, size_t size);函数的功能是为num个大小为size的元素开辟一块空间，并且把空间的每个字节初始化为0。与函
数malloc的区别只在于calloc会在返回地址之前把申请的空间的每个字节初始化为全0。
#include <stdio.h>
#include <stdlib.h>
int main()
{
int *p = (int*)calloc(10, sizeof(int));
if(NULL != p)
{
//使用空间
}
free(p);
p=NULL;
return 0;
}1.3? realloc函数
? ? ? ?realloc函数的出现让动态内存管理更加灵活。有时会我们发现过去申请的空间太小了，有时候我们又会觉得申请的空间过大了，那为了合理的时候内存，我们一定会对内存的大小做灵活的调整。那realloc函数就可以做到对动态开辟内存大小的调整。
void* realloc (void* ptr, size_t size);ptr是要调整的内存地址
size 调整之后新大小
返回值为调整之后的内存起始位置。
这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到新的空间。
int main()
{
//申请10个int的空间
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++)
{
*(p + i) = i;
}
//空间不够了，增加空间至20 个int
int*ptr = (int*)realloc(p, 20*sizeof(int));
if (ptr != NULL)
{
p = ptr;//如果开辟成功，将ptr赋值给p
}
else
{
return -1;
}
for (i = 10; i < 20; i++)
{
*(p + i) = i;
}
//打印
for (i = 0; i < 20; i++)
{
printf("%d ", *(p + i));
}
//释放空间
free(p);
p = NULL;
return 0;
}
realloc在调整内存空间的是存在两种情况：
第一种：原有空间之后有足够大的空间，此时要扩展内存就直接原有内存之后直接追加空间，原来空间的数据不发生变化。
第二种：原有空间之后没有足够大的空间，在堆空间上另找一个合适大小的连续空间来使用。这样函数返回的是一个新的内存地址。
2.常见的动态内存错误
2.1对NULL指针的解引用操作
void test()
{
int *p = (int *)malloc(20);
*p = 20;//如果p的值是NULL，解引用就会有问题
free(p);
}2.2 对动态开辟空间的越界访问
int main()
{
int* p = (int*)malloc(200);
if (p == NULL)
{
return -1;
}
//使用
int i = 0;
//越界访问
for (i = 0; i < 80; i++)//因为此时只开辟200字节，最多放50个元素，访问80个已经越界
{
*(p + i) = i;
}
for (i = 0; i < 80; i++)
{
printf("%d\n", *(p + i));
}
//释放
free(p);
p = NULL;
return 0;
}
2.3 对非动态开辟内存使用free释放
void test()
{
int a = 10;
int *p = &a;
free(p);
}此时free函数的行为是未定义的
2.4 使用free释放一块动态开辟内存的一部分
void test()
{
int *p = (int *)malloc(100);
p++;
free(p);//p不再指向动态内存的起始位置
}此时p指针指向空间最后的地址，因此free函数不能完全释放
2.5 对同一块动态内存多次释放
void test()
{
int *p = (int *)malloc(100);
free(p);
free(p);//重复释放
}2.6 动态开辟内存忘记释放（内存泄漏）
int main()
{
int *p = (int*)malloc(40);
if (p == NULL)
return -1;
//使用
//忘记释放了
getchar();//
return 0;
}
3.动态内存经典笔试题
题1：
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;
}此时的程序运行会有什么问题呢？
? ? ? ?首先我们建立一个char*类型的空指针，然后我们调用GetMemory函数，str是值传递，用p来接收，因此p是str的一份临时拷贝，所以当malloc开辟的空间起始地址放在p中的时候，不会影响str,str仍然是NULL指针。当str是空指针的时候，strcpy是不能直接将字符串直接拷贝到str空间的，因为NULL指向的空间是不能直接被访问的，因此程序会崩溃。
既然如此，我们应该如何改正呢？
我们可以将值传递改为址传递，或者强行将malloc开辟的空间带回来
下面我们看正确代码：
方法1：传址操作
void GetMenory(char** p)//一级指针str的地址用二级指针p接收
{
*p = (char *)malloc(100);//*p表示str
}
void Test(void)
{
char *str = NULL;
GetMemory(&str);
strcpy(str, "hello world");
printf(str);
free(str);
str = NULL;
}
int main()
{
Test();
return 0;
}方法2：强行带回p
void GetMenory(char* p)
{
p = (char *)malloc(100);
return p;
}
void Test(void)
{
char *str = NULL;
str=GetMemory(str);
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;
}
void Test(void)
{
char *str = NULL;
str = GetMemory();
printf(str);
}
?此题打印的是随机值：
? ? ? ?主要是因为我们调用GetMemory函数的时候，在里面创建了字符数组，再带回来时，创建的数组已经销毁，因此str打印出来的是随机值。创建数组的时候前面加static静态变量就可以。
题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;
}此题是传址操作，前面都没问题，可是strcpy将字符串复制之后，并没有释放malloc开辟的空间，因此会造成内存泄漏。后面加上free(str);str=NULL;即正确。
题4：
void Test(void)
{
char *str = (char *)malloc(100);
strcpy(str, "hello");
free(str);
if (str != NULL)
{
strcpy(str, "world");
printf(str);
}
}此处char* str接收malloc开辟的空间，后面使用完之后，并没有将str置为空指针，就直接判断str是否为空，此时这里的str是个野指针，因此free(str)之后str=NULL,则正确
4.C/C++程序的内存开辟
?
?C/C++程序内存分配的几个区域：
1. 栈区（stack）：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。 栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。
2. 堆区（heap）：一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。分配方式类似于链表。
3. 数据段（静态区）（static）存放全局变量、静态数据。程序结束后由系统释放。
4. 代码段：存放函数体（类成员函数和全局函数）的二进制代码。
5.柔性数组
5.1柔性数组概念
C99 中，结构中的最后一个元素允许是未知大小的数组，这就叫做柔性数组成员。
?
typedef struct st_type
{
int i;
int a[0];//柔性数组成员
}type_a;5.2柔性数组的特点
结构中的柔性数组成员前面必须至少一个其他成员。
sizeof 返回的这种结构大小不包括柔性数组的内存。
包含柔性数组成员的结构用malloc ()函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小。
即柔性数组一般与动态开辟内存配合使用:
举例：
#include <errno.h>.
struct st_type
{
int i;
int a[];
};
int main()
{
struct st_type* ps = (struct st_type*)malloc(sizeof(struct st_type) + 10 * sizeof(int));
if (ps == NULL)
{
printf("%s\n", strerror(errno));
return -1;
}
//开辟成功
ps->i = 100;
int i = 0;
for (i = 0; i < 10;i++)
{
ps->a[i] = i;
}
for (i = 0; i < 10; i++)
{
printf("%d ", ps->a[i]);
}
//a数组空间内容不够了，希望调整为20个整形数据
struct st_type* ptr = (struct st_type*)realloc(ps, sizeof(struct st_type) + 20 * sizeof(int));
if (ptr == NULL)
{
printf("扩展空间失败\n");
return -1;
}
else
{
ps = ptr;
}
//使用
//释放
free(ps);
ps = NULL;
return 0;
}5.3柔性数组的优势
上个柔性数组也有另一种使用方式：
typedef struct st_type
{
int i;
int *p_a;
}type_a;
type_a* p = (type_a *)malloc(sizeof(type_a));
p->i = 100;
p->p_a = (int *)malloc(p->i*sizeof(int));
for(i=0; i<100; i++)
{
p->p_a[i] = i;
}
//释放空间
free(p->p_a);
p->p_a = NULL;
free(p);
p = NULL;但此处free释放malloc开辟的空间要释放两次，柔性数组只需要释放一次。
使用柔性数组好处1：方便内存释放
? ? ? ? ? ? ? ? ? ? ? ? ? ? ?2：连续的内存有益于提高访问速度，也有益于减少内存碎片。