目录
题目1：运行Test函数的结果？（p = (char*)malloc(100)）
本笔记参考：B站up：鹏哥C语言
我们已经掌握的内存开辟方法有：
int val = 20;//在栈空间上开辟4个字节
char arr[10] = { 0 };//在栈空间上开辟10个字节的连续空间但是上述开辟空间的方式有两个特点：
但是在上一篇笔记中我们提到，有时候我们需要的空间大小只有在运行程序时才能知道，这时候在编译时开辟空间的方法就不能满足我们的需求了。
而这种时候，就需要动态内存开辟。
复习知识点：内存区域的划分
malloc - 负责动态内存开辟的函数
这个函数会向内存申请一块连续可用的空间，并返回指向这块空间的指针。
- 如果开辟成功，返回一个指向已开辟空间的指针；
- 如果开辟失败，则返回一个NULL指针（因此 malloc函数 的返回值一定要做检查）。
- 返回值的类型是void*，所以malloc函数并不知道开辟空间的类型，类型是在具体使用的时候由使用者自己决定的。
- 如果参数 size 为 0 ，malloc函数的行为是标准未定义的，这时候就取决于编译器了。（参数size - 需要开辟的字节数）
free - 负责释放和回收动态内存的函数
- 如果参数 ptr 正常指向malloc函数开辟的动态内存空间，则将空间还给操作系统；
- 如果参数 ptr 指向的空间不是动态开辟的，则会导致未定义的行为；
- 如果参数 ptr 是NULL指针，则函数什么事都不做。
malloc函数和free函数都在头文件 stdlib.h 中被声明 （这两个函数总是成对使用）。
简单的使用例
#include<stdlib.h>
#include<stdio.h>
int main()
{
//假设开辟10个整型的空间
int arr[10];//在栈区上开辟
//如果使用动态内存开辟：
int* p = malloc(10*sizeof(int));
return 0;
}注：
如果是接收的指针是void*的指针，则无法解引用，故不使用void*进行接收；
之所以使用int*，是为了以整型指针的方式使用传回来的指针（因为要求是开辟10个整型的空间）；
在一些编译器上，为了防止出现警告，最好在malloc函数前面加上一个强制类型转换，如：
int* p = (int*)malloc(10*sizeof(int));如果空间开辟成功，相当于在堆区上找了一块40个字节的空间，返回了这块空间的起始地址：
所以如果要使用 malloc函数开辟的这40个字节的空间时，应该：
//接之前的代码
if (p == NULL)//判断空间是否开辟失败
{
perror("main");
//perror函数会以 main:xxxxxxxx 的格式打印
}
//可以使用
int i = 0;
for ( i = 0; i < 10; i++)
{
*(p + i) = i;
//以整型指针的方式往后逐个访问每一个元素
}
for ( i = 0; i < 10; i++)
{
printf("%d ", p[i]);//p[i] 等价于 *(p + i)
}
//当不需要使用以开辟的空间时，需要回收空间
free(p);
p = NULL;//自己动手，把指针p设置为空指针
//……（之后的代码）其中，对于 free(p);
这种写法把指针p指向的空间还给了操作系统，但此时指针p依然保存着原空间的地址（存在非法访问风险）
ps：如果写入诸如 int* p = malloc(100000000000*sizeof(int)); 这样的代码，有可能开辟空间失败：
没有足够空间。
calloc函数也是用于动态内存分配的。
- 函数的功能是在堆区上开辟元素个数为 num，每个元素的长度为 size（单位为字节）的一块连续空间，并且把空间的每个字节初始化为0。
- 与malloc函数的区别在于calloc函数会在返回地址之前把申请的空间的每个字节初始化为0。
如果使用malloc函数开辟空间，打印发现：
对于所开辟的空间内部到底有什么，这是我们无法得知的。
但是如果使用calloc函数开辟空间：
调试：
这时所开辟空间的内存全部都被初始化成了0。
使用例
#include<stdio.h>
#include<stdlib.h>
int main()
{
int* p = (int*)calloc(10, sizeof(int));
if (p != NULL)
{
//使用空间
}
free(p);
p = NULL;
return 0;
}realloc - 改变所开辟的动态内存大小的函数
- realloc函数的出现让动态内存管理更加灵活。
- 有时候我们发现曾经申请的空间太小了，有时候我们又会觉得申请的空间过大了。为了合理地使用内存，就需要对内存的大小做灵活的调整，而 realloc 函数就可以做到对开辟的动态内存的大小进行调整。
- ptr 是要调整的内存地址；
- size 是动态内存调整后的大小；
- 返回值为调整后的内存的起始地址。
- 这个函数在调整动态内存大小的同时，还会将原来在这块动态内存空间中的数据移动到新的空间内。
◆realloc函数在调整内存空间的大小时存在两种情况：
◇情况1：原有空间之后有足够大的空间
这时realloc函数像malloc函数一样会申请空间，并返回这块空间的起始地址。
◇情况2：原有空间之后没有足够空间
这时候realloc函数会在内存中重新寻找一块空间：
（这块空间的大小可以满足要求）
①realloc函数会把原本空间内的内容拷贝到新的空间里；
②然后返回新空间的起始地址，同时把原本开辟的空间还给操作系统。
ps：如果realloc函数始终无法找到合适的空间来调控大小，这时函数就会返回一个NULL指针。这也是为什么不可以用指向原本空间的指针接收realloc函数的返回值，这可能会导致指针连原本的空间都无法找到。
通常会拿一个临时指针接收realloc的返回值，进行判断，如果不是空指针，再将临时指针的地址赋给原本的指针。
如：
执行代码
观察内存
可以发现，ptr 和 p 指向的地址是不同的。
使用例
realloc函数在单独使用时可以达到和malloc函数相似的功能 - 直接在堆区中开辟空间
#include<stdlib.h>
int main()
{
int* p = (int*)realloc(NULL, 40);
return 0;
}补充：
参数 size 如果是 0 ：
在C90中，参数 ptr 所指向的空间会被还给操作系统（类似于free），同时返回NULL指针。
在C99或者C11中，函数的执行取决于特定的库的实现。
int main()
{
int* p = (int*)malloc(1000000000);
int i = 0;
for ( i = 0; i < 10; i++)
{
*(p + i) = i;
//万一指针 p 指向的空间开辟失败，就会出现空指针，
//这时候的操作是对空指针而言的，就是非法访问内存了。
}
return 0;
}需要对malloc函数的返回值进行判断。
int main()
{
int* p = (int*)malloc(10 * sizeof(int));
if (p == NULL)
return 1;
int i = 0;
for (i = 0; i < 40; i++)
{
*(p + i) = i;
}
return 0;
}越界访问了：
int main()
{
int arr[10] = { 0 };//在栈区上开辟了空间
int* p = arr;
//使用 省略代码
free(p);//使用free函数释放了非动态开辟的空间
p = NULL;
return 0;
}这里演示在VS2022下强行执行该代码的结果：
代码挂掉了。
int main()
{
int* p = malloc(10 * sizeof(int));
if (p == NULL)
return 1;
int i = 0;
for (i = 0; i < 5; i++)
{
*p++ = i;
//这种写法确实可以把 i 填入前5个元素
//但是这时候指针 p 的位置也往前走了5个元素
}
free(p);
//这时候就会出现问题
return 0;
}这种写法会出现：
导致指针 p 不在起始位置，从而存在两个风险：
如果强制执行，代码也会卡死：
int main()
{
int* p = (int*)malloc(100);
//使用代码的部分省略
//释放
free(p);
//再次释放
free(p);
return 0;
}这种写法还是会有问题。
如何防止？只要在free函数使用后，将指针 p 置为NULL指针即可（当一个NULL指针被传入free函数时，什么事也不会发生）。
//释放
free(p);
p = NULL;
//再次释放
free(p);void test()
{
int* p = (int*)malloc(100);
if (p == NULL)
{
return;
}
//使用代码的部分 - 省略
}
int main()
{
test();
//之后的代码部分 - 也省略
return 0;
}
注意：malloc函数开辟的空间只有两种情况可以销毁
- 通过free函数主动释放；
- 程序结束，生命周期结束。
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;
}结果：
代码挂了。
分析：
那么如何改正？
一种改法：
注意：和栈区不同，堆区开辟的空间是不会自动销毁的，所以才可以进行诸如 return p 的操作。
补充：
在上面的代码中，出现了这种写法：printf(str); 其实这种写法是可行的。
例如：
printf("Hello World");打印这样的一串字符串，实际上是存在一个指针p，有：
char* p = "Hello World";即把字符'H'的地址放入p中，printf函数再从指针p指向的这个地址向后打印。
另一种改法：
char* GetMemory(void)
{
char p[] = "Hello World";
return p;
}
void Test(void)
{
char* str = NULL;
str = GetMemory();
printf(str);
}
int main()
{
Test();
return 0;
}运行结果：
分析：
补充：野指针问题
int* f2(void) { int* ptr; *ptr = 10; return ptr; }在里面指针ptr没有初始化，就是个野指针。
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;
}void Test(void)
{
char* str = (char*)malloc(100);
strcpy(str, "Hello");
free(str);
if (str != NULL)
{
strcpy(str, " World");
printf(str);
}
}
int main()
{
Test();
return 0;
}分析：
如果提前所以free函数，会出现：
这题告诉我们：free函数后面一定要进行置为空指针的操作。
解释static关键字修饰局部变量：
普通的局部变量是在栈区上分配空间的，栈区的特点是在上面创建的变量出了作用域就销毁。
但是被static修饰的变量存放在数据段（静态区），数据段的特点是在上面创建的变量，直到程序结束才销毁。
所以可以使用static关键字延长局部变量的生命周期。
C99中，结构中的最后一个元素允许是未知大小的数组，这就叫做【柔性数组】成员。
例如：
struct S
{
int n;
int arr[];//这个数组的大小是未知的
};其中的数组arr就是柔性数组。另外还有一种写法：
struct S
{
int n;
int arr[0];
};其中的arr同样是柔性数组，这两种写法根据编译器的不同而不同。
例如：
struct S
{
int n;
int arr[];//柔性数组成员
};
int main()
{
//期望数组arr的大小是10个整型
struct S* ps = (struct S*)malloc(sizeof(struct S) + 10 * sizeof(int));
return 0;
}这时候指针ps指向的空间：
使用开辟的柔性数组：
通过调试可以看到arr数组的变化：
完整的使用例：
struct S
{
int n;
int arr[];//柔性数组成员
};
int main()
{
//期望数组arr的大小是10个整型
struct S* ps = (struct S*)malloc(sizeof(struct S) + 10 * sizeof(int));
ps->n = 10;
int i = 0;
for ( i = 0; i < 10; i++)
{
ps->arr[i] = i;
}
//增加空间
struct S* ptr = realloc(ps, sizeof(struct S) + 20 * sizeof(int));
if (ptr != NULL)
{
ps = ptr;
}
//使用 - 省略
free(ps);
ps = NULL;
return 0;
}存在疑问：
只要这样创建数组
struct S
{
int n;
int* arr;
};之后对指针arr进行动态内存开辟似乎也可以达到同样的效果，那为什么还需要柔性数组呢？
也就是说，此时如果arr还需要指向一块空间，就还需要一个malloc函数专门为arr进行动态开辟。只有这样，才能保证ps指向的空间和arr指向的空间都开辟在堆上。
可以这样使用：
struct S
{
int n;
int* arr;
};
int main()
{
struct S* ps = (struct S*)malloc(sizeof(struct S));
if (ps == NULL)
return 1;
ps->n = 10;
ps->arr = (int*)malloc(10 * sizeof(int));
if (ps->arr == NULL)
return 1;
int i = 0;
for ( i = 0; i < 10; i++)
{
ps->arr[i] = i;
}
int* ptr = realloc(ps->arr, 20 * sizeof(int));
if (ptr != NULL)
{
ps->arr = ptr;
}
//使用 - 使用
//释放
free(ps->arr);
ps->arr = NULL;
free(ps);
ps = NULL;
return 0;
}还需要注意释放问题：
似乎这种方法也可以达成目的。但是，这种方法存在缺点：
空间局部性：当使用了某个位置的内存时，接下来有80%的概率使用这个位置周边内存的数据。
所以如果使用上面所述的做法，n 和 arr 可能在空间上不是连续的，当需要访问时，效率就可能受到影响。