1. 为什么存在动态内存分配

int val = 20;//在栈空间上开辟四个字节
char arr[10] = {0};//在栈空间上开辟10个字节的连续空间

2. 动态内存函数的介绍

2.1 malloc：stdlib.h

void* malloc (size_t size);
int* p = (int*)malloc(40);

#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <stdio.h>int main()
{//向内存申请10个整形的空间int* p = (int*)malloc(40);if (p == NULL){//打印错误原因的一个方式printf("%s\n", strerror(errno));}else{//正常使用空间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断开，但是实际上p还是存储内容，所以我们手动设置为nullp = NULL;return 0;
}

2.2 free:stdlib.h

是用来做动态内存的释放和回收的

注意点：free(str)后，实际上str还执行一个空的地址，所以此时str!=NULL

void free (void* ptr);

2.3 calloc

calloc 函数也用来动态内存分配。可以初始化空间。

void* calloc (size_t num, size_t size);
int*p = (int*)calloc(10, sizeof(int));

int main()
{//malloc(10*sizeof(int))int*p = (int*)calloc(10, sizeof(int));if (p == NULL){printf("%s\n", strerror(errno));}else{int i = 0;for (i = 0; i < 10; i++){printf("%d ", *(p + i));}}//释放空间//free函数是用来释放动态开辟的空间的free(p);p = NULL;return 0;
}

2.4 realloc

当初始申请空间不够，这时使用realloc开辟新的空间【调整动态开辟内存空间的大小】

使用注意点：

1. 如果p指向的空间之后有足够的内存空间可以追加，则直接追加，后返回p
2. 如果p指向的空间之后没有足够的内存空间可以追加，则realloc函数会重新找一个新的内存区域
开辟一块满足需求的空间，并且把原来内存中的数据拷贝回来，释放旧的内存空间
最后返回新开辟的内存空间地址
3. 得用一个新的变量来接受realloc函数的返回值

void* realloc (void* ptr, size_t size);

#include <stdio.h>
int main()
{int *ptr = (int*)malloc(100);if(ptr != NULL){//业务处理}else{exit(EXIT_FAILURE);    }//扩展容量//代码1ptr = (int*)realloc(ptr, 1000);//这样可以吗？(如果申请失败会如何？)//代码2int*p = NULL;p = realloc(ptr, 1000);if(p != NULL){ptr = p;}//业务处理free(ptr);return 0;
}

3. 常见的动态内存错误

3.1 对NULL指针的解引用操作

//1. 对NULL进行解引用操作int *p = (int*)malloc(40);//万一malloc失败了，p就被赋值为NULL//所以我们在申请完一块空间之后，一定要进行判空操作*p = 0;//errint i = 0;for (i = 0; i < 10; i++){*(p + i) = i;//err}free(p);p = NULL;

3.2 对动态开辟空间的越界访问

//2. 对动态开辟的内存的越界访问int *p = (int*)malloc(5 * sizeof(int));if (p == NULL){return 0;}else{int i = 0;for (i = 0; i < 10; i++){*(p + i) = i;}}//free(p);p = NULL;

3.3 对非动态开辟内存使用free释放

//栈区开辟出来的，不是动态开辟int a = 10;int* p = &a;*p = 20;//3. 对非动态开辟内存的freefree(p);p = NULL;return 0;

3.4 使用free释放一块动态开辟内存的一部分

int*p = (int*)malloc(40);if (p == NULL){return 0;}int i = 0;for (i = 0; i < 5; i++){*p++ = i;}//回收空间// 使用free释放动态开辟内存的一部分free(p);p =NULL;

3.5 对同一块动态内存多次释放

int *p = (int*)malloc(40);if (p == NULL){return 0;}//使用//释放free(p);//将p设置为空指针，可以防止重复释放产生的错误p = NULL;

3.6 动态开辟内存忘记释放（内存泄漏）

while (1){malloc(1);}

4. 几个经典的笔试题

4.1 题目1：

//面试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();char*str = "abcdef";printf("%s\n", str);printf(str);printf("abcdef");return 0;
}

修改结果

void GetMemory(char **p)//**p：是p的地址
{//*p：是p的内容*p = (char *)malloc(100);
}void Test(void)
{char *str = NULL;GetMemory(&str);//传地址strcpy(str, "hello world");printf(str);free(str);str = NULL;
}int main()
{Test();return 0;
}

char* GetMemory(char *p)
{p = (char *)malloc(100);//将p传递除去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;
}

4.2 题目2：

【存储在栈区中的数据，出了函数则就会被销毁】

//面试2
char *GetMemory(void)
{char p[] = "hello world";//局部变量//跳出此函数，则p被销毁return p;
}void Test(void)
{char *str = NULL;str = GetMemory();//此时str的p的地址printf(str);//非法地址访问，故输出随机值
}int main()
{Test();return 0;
}

【数据存储在静态区(static)，出了函数数据还是存在】

//在静态区，出了函数还是可以继续使用
int* test()
{//使用static，将a放入静态区，出了这个函数，内存并没有被销毁，故在外面还可以访问到static int a = 10;//静态区int a = 10;//栈区 return &a;
}int main()
{int*p = test();//此时p接收到a的地址*p = 20;//将a修改为20return 0;//20
}

【数据存储在堆区，出了函数数据还是存在】

//在堆区，出函数还是存在
int* test()
{int *ptr = malloc(100);//堆区return ptr;
}int main()
{int *p = test();return 0;
}

4.3 题目3：

void GetMemory(char **p, int num)
{*p = (char *)malloc(num);//给p创建100个新的char
}
void Test(void)
{char *str = NULL;GetMemory(&str, 100);strcpy(str, "hello");//可以输出printf(str);//改：忘记free内容，导致内存泄露free(str);str = NULL;
}

4.4 题目4：

void Test(void)
{char *str = (char *)malloc(100);strcpy(str, "hello");free(str);//free了但是没有把指针置为null//此处的问题：已经释放的空间，还被使用if (str != NULL)//则此时str还不为NUll，则进入判断{strcpy(str, "world");printf(str);}
}int main()
{Test();//worldreturn 0;
}

解决：

void Test(void)
{char* str = (char*)malloc(100);strcpy(str, "hello");free(str);//解决：将str置为NULLstr = NULL;if (str != NULL){strcpy(str, "world");printf(str);}
}int main()
{Test();//worldreturn 0;
}

5. C/C++程序的内存开辟

C/C++程序内存分配的几个区域：

1. 栈区（stack）：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。

2. 堆区（heap）：一般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收。分配方式类似于链表。

3. 数据段（静态区）（static）存放全局变量、静态数据。程序结束后由系统释放。

4. 代码段：存放函数体（类成员函数和全局函数）的二进制代码。

6. 柔性数组

结构中的最后一个元素允许是未知大小的数组，这就叫做『柔性数组』成员。

struct S
{int n;int arr[10];
};struct S
{int n;int arr[];//未知大小的
};struct S
{int n;int arr[0];//未知大小的-柔性数组成员-数组的大小是可以调整的
};

6.1 柔性数组的特点：

结构中的柔性数组成员前面必须至少一个其他成员。
sizeof 返回的这种结构大小不包括柔性数组的内存。
包含柔性数组成员的结构用malloc ()函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小。

//代码1
int i = 0;
type_a *p = (type_a*)malloc(sizeof(type_a)+100*sizeof(int));
//业务处理
p->i = 100;
for(i=0; i<100; i++)
{p->a[i] = i;
}
free(p);

6.2 柔性数组的使用--int[] a

struct S
{int n;int arr[0];//未知大小的-柔性数组成员-数组的大小是可以调整的
};int main()
{struct S s;printf("%d\n", sizeof(s));////sizeof(struct S)：不包括int arr的大小//5*sizeof(int)：手动的给arr赋值struct S* ps = (struct S*)malloc(sizeof(struct S)+5*sizeof(int));ps->n = 100;int i = 0;for (i = 0; i < 5; i++){ps->arr[i] = i;//0 1 2 3 4}//开辟内存struct S* ptr = realloc(ps, 44);if (ptr != NULL){ps = ptr;}for (i = 5; i < 10; i++){ps->arr[i] = i;}//打印arr所有数值for (i = 0; i < 10; i++){printf("%d ", ps->arr[i]);}//释放free(ps);ps = NULL;return 0;
}

6.3 柔性数组的扩展：int* arr

struct S
{int n;int* arr;
};
int main()
{//sizeof(struct S)：此时包括int* arrstruct S* ps = (struct S*)malloc(sizeof(struct S));//再一次给arr创建动态内存ps->arr = malloc(5 * sizeof(int));int i = 0;for (i = 0; i < 5; i++){ps->arr[i] = i;}for (i = 0; i < 5; i++){printf("%d ", ps->arr[i]);}//调整大小int* ptr = realloc(ps->arr, 10 * sizeof(int));if (ptr != NULL){ps->arr = ptr;}for (i = 5; i < 10; i++){ps->arr[i] = i;}for (i = 0; i < 10; i++){printf("%d ", ps->arr[i]);}//释放内存：注意释放顺序free(ps->arr);ps->arr = NULL;free(ps);ps = NULL;return 0;
}