# 7.1 存储管理函数
**Dynamic memory management**
**学习步骤：**
2023-11-23 周四
2024-03-24 Upload
## 7.1 malloc() / free()
`malloc()` 函数是 C 语言中用于动态分配内存的函数之一，它允许在程序运行时按需请求指定大小的内存空间。这个函数位于 `` 头文件中。
#### `malloc()` 函数的基本用法：
```
#include
void *malloc(size_t size);
```
* 参数： `size` 参数表示要分配的内存大小，以字节为单位。返回类型是 `void*`，即指向分配内存起始位置的指针。
* 返回值： 如果内存分配成功，返回指向分配内存的指针；如果分配失败，则返回 `NULL`。
#### 使用示例：
```c
#include
#include
int main() {
int *ptr;
int n = 5;
// 分配内存空间给指定大小的整型数组
ptr = (int *)malloc(n * sizeof(int));
if (ptr == NULL) {
printf("内存分配失败！\n");
return 1;
}
// 使用分配的内存空间
for (int i = 0; i < n; ++i) {
ptr[i] = i; // 对分配的内存进行写入
printf("%d ", ptr[i]); // 读取并输出分配的内存内容
}
// 释放动态分配的内存
free(ptr);
ptr = NULL; // 建议将指针置为 NULL，以避免悬空指针
return 0;
}
```
#### 注意事项：
1. 检查分配是否成功： 始终检查 `malloc()` 返回的指针是否为 `NULL`，以确保内存分配成功。
2. 释放动态分配的内存： 使用 `free()` 函数释放通过 `malloc()` 分配的内存，避免内存泄漏。
3. 类型转换： 在 C++ 中，不需要显式类型转换 `malloc()` 返回的指针，而在 C 中需要进行显式类型转换。
`malloc()` 是动态内存分配中最基本和常用的函数之一，但在使用时需要小心管理内存，避免内存泄漏和指针操作错误。随后的 C 标准引入了更多安全和方便的内存管理函数，如 `calloc()` 和 `realloc()`，它们可以更好地满足不同的需求。
当你使用 `malloc()` 分配了内存后，你可以将这块内存用于存储数据或进行其他操作。以下是一个示例，演示了如何正确分配内存并使用指针进行操作：
```c
#include
#include
#include
int main() {
int arr[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int *ptr = (int *)malloc(10 * sizeof(int)); // 分配足够存储 10 个整数的内存空间
if (ptr == NULL) {
printf("malloc failed: Unable to allocate memory\n");
return 1;
}
// 将数组 arr 的内容复制到动态分配的内存中
memcpy(ptr, arr, 10 * sizeof(int));
// 打印动态分配内存中的内容
for (int i = 0; i < 10; ++i) {
printf("%d ", ptr[i]);
}
printf("\n");
// 释放动态分配的内存
free(ptr);
ptr = NULL; // 将指针置为 NULL，避免悬空指针
return 0;
}
```
int \*ptr = (int \*)malloc(10 \* sizeof(int));: 使用 malloc() 函数分配了足够存储 10 个整数的内存空间，并将分配得到的地址赋值给了 ptr 指针。这行代码中的 (int \*) 是一种类型转换，将 malloc() 返回的 void\* 类型指针强制转换为 int\* 类型指针。
在这个示例中，我使用 `malloc()` 分配了足够存储 10 个整数的内存空间，并用 `memcpy()` 将数组 `arr` 的内容复制到了动态分配的内存中。然后通过循环打印了动态分配内存中的内容，最后使用 `free()` 释放了分配的内存。
这个例子展示了如何正确分配和使用动态内存。记得在不再需要动态分配的内存时使用 `free()` 函数来释放它，以免出现内存泄漏问题。
分配给一块空间，用，用完没有还，。 用去图书馆借书的例子理解， 借了，看完了，没还，别人也借不了。 然后我一直不还， 对图书馆来说，相当于书丢了，这就是“内存泄漏”。
开辟过程：
```c
// 将数组 arr 的内容复制到动态分配的内存中
memcpy(ptr, arr, 10 * sizeof(int));
// 打印动态分配内存中的内容
for (int i = 0; i < 10; ++i) {
printf("%d ", ptr[i]);
}
printf("\n");
// 释放动态分配的内存
free(ptr);
ptr = NULL; // 将指针置为 NULL，避免悬空指针
```
这段代码的作用是演示了动态内存的使用过程：
1. 内存复制： 使用 `memcpy()` 函数将数组 `arr` 中的内容复制到了动态分配的内存空间中，这样就把静态数组 `arr` 中的数据复制到了动态分配的内存中的位置 `ptr`。
2. 打印动态分配内存中的内容： 通过循环遍历动态分配内存中的内容，并使用 `printf()` 函数输出每个元素的值。
3. 释放动态分配的内存： 最后使用 `free()` 函数释放了动态分配的内存。这一步非常重要，因为在不再需要动态分配内存时，应该及时释放它，以免造成内存泄漏。
4. 将指针置为 NULL： 将指针 `ptr` 置为 `NULL` 是一种良好的习惯，可以避免出现悬空指针。悬空指针是指已经释放的内存却没有将指针设置为 `NULL`，这样的指针可能会导致程序错误的操作。
这段代码是一个简单的示例，展示了动态内存分配、使用和释放的基本流程。在实际编程中，使用动态内存时需要确保适当地分配和释放内存，避免内存泄漏和悬空指针的问题。
生成随机字符串： 这个例子对malloc的运用就很到位
```c
/* malloc example: random string generator*/
#include /* printf, scanf, NULL */
#include /* malloc, free, rand */
int main ()
{
int i,n;
char * buffer;
printf ("How long do you want the string? ");
scanf ("%d", &i);
buffer = (char*) malloc (i+1);
if (buffer==NULL) exit (1);
for (n=0; n` 头文件中定义的一个常量，表示 `rand()` 函数能够生成的最大随机数值。
* `rand()%26` 使用取余操作符 `%` 将 `rand()` 生成的随机整数限制在 0 到 25 之间。因为 `% 26` 可以得到 0 到 25 的余数。
* `'a'` 是字符 'a' 的 ASCII 值。在 ASCII 表中，小写字母 'a' 对应的 ASCII 值为 97。
所以，`rand()%26+'a'` 的含义是：生成一个 0 到 25 的随机整数，然后加上 ASCII 值 97（即小写字母 'a' 的 ASCII 值），得到的结果是一个随机小写字母的 ASCII 值。这个值会被存储在 `buffer[n]` 中，实现了生成随机小写字母的目的。
这段代码是一个简单的示例，用于生成随机字符串。
1. `printf ("How long do you want the string? ");`: 打印提示消息，询问用户希望生成的随机字符串的长度。
2. `scanf ("%d", &i);`: 从用户输入中读取一个整数，存储到变量 `i` 中，表示用户期望生成的字符串长度。
3. `buffer = (char*) malloc (i+1);`: 使用 `malloc()` 函数分配了 `i+1` 大小的内存空间，存储字符的缓冲区。为了存储字符串结束符 `\0`，分配的大小比用户输入的长度多了一个字符位置。`buffer` 指针指向这块分配的内存空间。
4. `if (buffer==NULL) exit (1);`: 检查 `malloc()` 是否成功分配了内存。如果 `buffer` 是 `NULL`，意味着分配失败，程序将以错误码 1 退出。
5. `for (n=0; n
`sizeof(int)` 就是表示整型 4
`p==NULL`表示 是否是悬空指针， 有没有申请成功，失败就结束 。`return 1` 。
```c
#include
#include
int main() {
int n;
int *ptr;
printf("Enter the number of elements: ");
scanf("%d", &n);
// 使用 calloc 分配 n 个整数大小的内存空间
ptr = (int *)calloc(n, sizeof(int));
if (ptr == NULL) {
printf("Memory allocation failed\n");
return 1;
}
printf("Memory allocated successfully\n");
// 打印分配的内存空间中的内容（此时应全为零）
printf("Content of allocated memory:\n");
for (int i = 0; i < n; ++i) {
printf("%d ", ptr[i]);
}
printf("\n");
// 释放动态分配的内存
free(ptr);
ptr = NULL;
return 0;
}
```
这个示例演示了使用 calloc() 函数分配了 n 个整数大小的内存空间，然后打印了分配的内存中的内容。由于 calloc() 分配的内存会初始化为零，所以在打印内容之前，所有的元素都应该是零。
这段代码是一个基本的示例，展示了 calloc() 函数的用法。在实际使用时，可以根据需求修改分配的内存空间的类型和大小，并根据需要进行更复杂的操作。记得在不再需要动态分配的内存时，使用 free() 函数释放它，避免内存泄漏问题。
```
// 打印分配的内存空间中的内容（此时应全为零）
printf("Content of allocated memory:\n");
for (int i = 0; i < n; ++i) {
printf("%d ", ptr[i]);
}
printf("\n");
```
让我解释下每行代码的作用：
1. printf("Content of allocated memory:\n");: 打印消息，说明即将输出分配的内存空间的内容。
2. for (int i = 0; i < n; ++i) { printf("%d ", ptr\[i]); }: 这个 for 循环遍历了动态分配的内存空间，依次输出每个元素的值。ptr\[i] 表示指针 ptr 指向的动态分配内存空间中第 i 个元素的值。
3. printf("\n");: 在 for 循环结束后，打印一个换行符，将输出的内容放在新的一行。
整个代码块的目的是，利用循环遍历打印了动态分配的内存空间中的内容，展示了 calloc() 函数初始化分配内存为零的特性。
calloc 函数的典型用法， 就这样记住就行。
```c
#include
#include
int main() {
char str[20] = "Hello, World!";
printf("Before memset: %s\n", str);
// 将 str 的前 5 个字符（包括 '\0' 结尾符）设置为 '*'
memset(str, '*', 5);
printf("After memset: %s\n", str);
return 0;
}
```
#### 
#### 注意事项：
* memset() 常用于将数组或其他内存块的一部分或全部内容设置为特定的值，比如清空数组、初始化某些数据结构等。
* 由于 value 参数是以整数形式给出的，因此将会被转换为 unsigned char 类型，所以可以用任何 unsigned char 类型表示的值来填充内存块，如 0、'A'、'\*' 等。
* 尽管 memset() 函数返回 void\* 类型的指针，但它实际上没有返回值。
## 7.3 realloc
#### realloc() 函数原型：
```
cCopy code
void *realloc(void *ptr, size_t size);
```
* ptr：指向之前由 malloc()、calloc() 或 realloc() 返回的内存块的指针。如果 ptr 是 NULL，则 realloc() 的行为类似于 malloc(size)。
* size：需要重新分配的内存块的新大小（以字节为单位）。
\
```c
#include
#include
int main() {
int *ptr;
// 分配初始内存空间
ptr = (int *)malloc(5 * sizeof(int));
if (ptr == NULL) {
printf("Memory allocation failed\n");
return 1;
}
printf("Memory allocated successfully\n");
// 扩大内存空间
ptr = (int *)realloc(ptr, 10 * sizeof(int)); // 10 * sizeof(int) >> 增加 50字节
if (ptr == NULL) {
printf("Memory reallocation failed\n");
return 1;
}
printf("Memory reallocated successfully\n");
free(ptr); // 释放内存
return 0;
}
```
当在代码中加入数组时，我们可以利用 `realloc()` 函数动态调整数组的大小。以下是一个示例，展示了如何动态增加数组的长度：
```
#include
#include
int main() {
int *arr = NULL; // 初始化指针为 NULL，表示未分配内存
int initialSize = 5;
int newSize = 10;
// 初始分配内存
arr = (int *)malloc(initialSize * sizeof(int));
if (arr == NULL) {
printf("Memory allocation failed\n");
return 1;
}
printf("Memory allocated successfully\n");
// 假设在此之前已经对 arr 进行了赋值操作...
// 重新分配更大的内存空间
arr = (int *)realloc(arr, newSize * sizeof(int));
if (arr == NULL) {
printf("Memory reallocation failed\n");
return 1;
}
printf("Memory reallocated successfully\n");
// 使用新的内存空间...
free(arr); // 释放内存
return 0;
}
```
这个示例展示了如何在初始分配了一定大小的内存后，使用 `realloc()` 函数动态地调整数组的大小。在实际使用中，你可以根据需求动态改变数组的大小，使其适应不同的场景和需求。值得注意的是，`realloc()` 可能会涉及内存的重新分配和数据的拷贝，所以在使用时需要注意内存分配失败的情况，并确保操作前后正确管理内存。
`realloc` 在申请空间的时候，
情况一，覆盖到别人的空间： 情况一比较复杂
怎么办？
找一块新的满足要求的空间， 第一步讲原来的值复制到新的空间去。 多的扩容的空间留着不用，返回的时候，直接返回新的地址。
可以看到这里，realloc 没有使用 p来进行接收，这就是因为，如果内存申请失败，p指向申请的这块地址的时候，申请失败，指不过来， 那天之前的地址，可能会“失忆”，有风险。
这就ok了，做一个中间转换，
情况二，后面没人用，直接增加。情况二是简单的。
---
# Agent Instructions: Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.
Perform an HTTP GET request on the current page URL with the `ask` query parameter:
```
GET https://labspc.gitbook.io/cnippets/chap8.-wen-jian-du-xie-yu-nei-cun-guan-li/8.4-cun-chu-guan-li-han-shu.md?ask=
```
The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.