函数字典 · 内存管理

malloc：动态分配内存空间

/*
 * 函数名称: malloc
 * 头文件: <stdlib.h>
 * 函数声明: void *malloc(size_t size);
 * 函数描述: 动态分配指定大小的内存空间，并返回指向该内存空间的指针。
 * 参数:
 *     - size: 要分配的内存空间大小（以字节为单位）
 *
 * 返回值:
 *     如果内存分配成功，则返回指向分配内存的指针，否则返回NULL。
 *
 * 使用示例:
 *     int *nums = (int*)malloc(sizeof(int) * 10); // 分配10个整型变量所占的内存空间
 *     if (nums == NULL) {
 *         perror("malloc");
 *     }
 *     // 使用分配的内存空间
 *     free(nums); // 释放内存空间
 *
 */

calloc：分配指定数量的内存块，并将其设置为零

/*
 * 函数名称: calloc
 * 头文件: <stdlib.h>
 * 函数声明: void *calloc(size_t num, size_t size);
 * 函数描述: 分配指定数量的内存块，并将每个字节设置为零。
 * 参数:
 *     - num: 要分配的内存块的数量
 *     - size: 每个内存块的大小（以字节为单位）
 *
 * 返回值:
 *     如果内存分配成功，则返回指向分配内存的指针，否则返回NULL。
 *
 * 使用示例:
 *     int *nums = (int*)calloc(10, sizeof(int)); // 分配10个整型变量所占的内存空间，并将每个字节都设置为零。
 *     if (nums == NULL) {
 *         perror("calloc");
 *     }
 *     // 使用分配的内存空间
 *     free(nums); // 释放内存空间
 *
 */

realloc：重新分配内存空间大小

/*
 * 函数名称: realloc
 * 头文件: <stdlib.h>
 * 函数声明: void *realloc(void *ptr, size_t size);
 * 函数描述: 重新分配已分配内存空间的大小，并返回指向新分配内存的指针。
 * 参数:
 *     - ptr: 指向已分配内存空间的指针
 *     - size: 新的内存空间大小（以字节为单位）
 *
 * 返回值:
 *     如果内存重新分配成功，则返回指向新分配内存的指针；如果失败，则返回NULL。
 *     如果ptr为NULL，则该函数等效于malloc(size)。
 *     如果size为0，且ptr不为NULL，则该函数等效于free(ptr)。
 *
 * 使用示例:
 *     int *nums = (int*)malloc(sizeof(int) * 5); // 分配5个整型变量所占的内存空间
 *     if (nums == NULL) {
 *         perror("malloc");
 *     }
 *     // 修改内存空间大小为10个整型变量所占的内存空间
 *     int *newNums = (int*)realloc(nums, sizeof(int) * 10);
 *     if (newNums == NULL) {
 *         perror("realloc");
 *         free(nums); // 释放之前分配的内存空间
 *     } else {
 *         nums = newNums; // 更新指针，指向新分配的内存空间
 *     }
 *     // 使用重新分配的内存空间
 *     free(nums); // 释放内存空间
 *
 */

free：释放动态分配的内存空间

/*
 * 函数名称: free
 * 头文件: <stdlib.h>
 * 函数声明: void free(void *ptr);
 * 函数描述: 释放动态分配的内存空间。
 * 参数:
 *     - ptr: 指向要释放的内存空间的指针
 *
 * 返回值: 无
 *
 * 使用示例:
 *     int *nums = (int*)malloc(sizeof(int) * 10); // 分配10个整型变量所占的内存空间
 *     if (nums == NULL) {
 *         perror("malloc");
 *     }
 *     // 使用分配的内存空间
 *     free(nums); // 释放内存空间
 *
 */

memset：设置内存块的值

/*
 * 函数名称: memset
 * 头文件: <string.h>
 * 函数声明: void *memset(void *ptr, int value, size_t num);
 * 函数描述: 将指定内存块的每个字节都设置为给定的值。
 * 参数:
 *     - ptr: 指向要设置的内存块的指针
 *     - value: 要设置的字节值（作为int类型传入，但会自动转换为unsigned char类型）
 *     - num: 设置的字节数（以字节为单位）
 *
 * 返回值:
 *     返回指向设置后的内存块的指针（即，ptr的值）。
 *
 * 使用示例:
 *     int nums[5];
 *     memset(nums, 0, sizeof(int) * 5); // 将nums数组的每个元素都设置为0
 *
 */

memcpy：内存块之间的拷贝

/*
 * 函数名称: memcpy
 * 头文件: <string.h>
 * 函数声明: void *memcpy(void *dest, const void *src, size_t num);
 * 函数描述: 将源内存块中的内容拷贝到目标内存块中。
 * 参数:
 *     - dest: 指向目标内存块的指针
 *     - src: 指向源内存块的指针
 *     - num: 拷贝的字节数（以字节为单位）
 *
 * 返回值:
 *     返回指向目标内存块的指针（即，dest的值）。
 *
 * 注意事项:
 *     - 目标内存块的大小必须足够大以容纳要拷贝的数据。
 *     - 源内存块和目标内存块不能重叠，如果重叠，则结果是未定义的。
 *
 * 使用示例:
 *     char src[] = "Hello";
 *     char dest[10];
 *     memcpy(dest, src, sizeof(src)); // 将src中的内容拷贝到dest中
 *
 */

memmove：内存块之间的安全拷贝

/*
 * 函数名称: memmove
 * 头文件: <string.h>
 * 函数声明: void *memmove(void *dest, const void *src, size_t num);
 * 函数描述: 将源内存块中的内容安全地拷贝到目标内存块中。
 * 参数:
 *     - dest: 指向目标内存块的指针
 *     - src: 指向源内存块的指针
 *     - num: 拷贝的字节数（以字节为单位）
 *
 * 返回值:
 *     返回指向目标内存块的指针（即，dest的值）。
 *
 * 注意事项:
 *     - 目标内存块的大小必须足够大以容纳要拷贝的数据。
 *     - 源内存块和目标内存块可以重叠，memmove会确保正确的拷贝。
 *
 * 使用示例:
 *     char src[] = "Hello";
 *     char dest[10];
 *     memmove(dest, src, sizeof(src)); // 将src中的内容安全地拷贝到dest中
 *
 */

mmap：创建内存映射区域

/*
 * 函数名称: mmap
 * 头文件: <sys/mman.h>
 * 函数声明: void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset);
 * 函数描述: 创建一个内存映射区域，将磁盘文件或共享内存对象映射到进程的虚拟内存空间中。
 * 参数:
 *     - addr: 映射区域的首地址，一般设置为0，让系统自动选择
 *     - length: 映射区域的大小（以字节为单位）
 *     - prot: 内存区域的保护标志，用于限制访问权限，可选值包括：
 *             PROT_NONE：不可访问
 *             PROT_READ：可读
 *             PROT_WRITE：可写
 *             PROT_EXEC：可执行
 *     - flags: 内存映射的标志，用于指定映射行为，可选值包括：
 *              MAP_SHARED：与其他进程共享映射区域
 *              MAP_PRIVATE：创建一个私有的映射区域
 *              MAP_FIXED：强制使用指定的地址作为映射区域的起始地址
 *              MAP_ANONYMOUS：创建匿名映射区域，不与磁盘文件关联
 *     - fd: 要映射的文件描述符
 *     - offset: 文件中的偏移量，指定从文件的哪个位置开始映射，一般设置为0
 *
 * 返回值:
 *     成功时，返回映射区域的起始地址；失败时，返回MAP_FAILED (-1)。
 *
 * 使用示例:
 *     int fd = open("file.txt", O_RDWR);
 *     if (fd == -1) {
 *         perror("open");
 *     }
 *     off_t offset = 0;
 *     size_t length = 4096; // 映射4KB的内存
 *     void *addr = mmap(NULL, length, PROT_READ | PROT_WRITE, MAP_SHARED, fd, offset);
 *     if (addr == MAP_FAILED) {
 *         perror("mmap");
 *         close(fd);
 *     }
 *     // 使用映射的内存区域
 *     // ...
 *     munmap(addr, length); // 解除内存映射
 *     close(fd);
 *
 */

munmap：解除内存映射

/*
 * 函数名称: munmap
 * 头文件: <sys/mman.h>
 * 函数声明: int munmap(void *addr, size_t length);
 * 函数描述: 解除先前通过mmap函数创建的内存映射区域。
 * 参数:
 *     - addr: 要解除映射的区域的起始地址
 *     - length: 解除映射的区域大小（以字节为单位）
 *
 * 返回值:
 *     成功时，返回0；失败时，返回-1，并设置errno。
 *
 * 使用示例:
 *     int result = munmap(addr, length);
 *     if (result == -1) {
 *         perror("munmap");
 *     }
 *
 */

mlock：锁定内存页

/*
 * 函数名称: mlock
 * 头文件: <sys/mman.h>
 * 函数声明: int mlock(const void *addr, size_t len);
 * 函数描述: 锁定指定的内存页，将其驻留在物理内存中，防止被交换到磁盘上。
 * 参数:
 *     - addr: 要锁定的内存页的起始地址
 *     - len: 锁定的内存页的长度（以字节为单位）
 *
 * 返回值:
 *     成功时，返回0；失败时，返回-1，并设置errno。
 *
 * 注意事项:
 *     - mlock函数需要获取足够的权限才能锁定内存页。
 *     - 锁定过多的内存页可能会导致系统资源不足。
 *
 * 使用示例:
 *     int result = mlock(addr, length);
 *     if (result == -1) {
 *         perror("mlock");
 *     }
 *
 */

munlock：解锁内存页

/*
 * 函数名称: munlock
 * 头文件: <sys/mman.h>
 * 函数声明: int munlock(const void *addr, size_t len);
 * 函数描述: 解锁先前通过mlock函数锁定的内存页。
 * 参数:
 *     - addr: 要解锁的内存页的起始地址
 *     - len: 解锁的内存页的长度（以字节为单位）
 *
 * 返回值:
 *     成功时，返回0；失败时，返回-1，并设置errno。
 *
 * 使用示例:
 *     int result = munlock(addr, length);
 *     if (result == -1) {
 *         perror("munlock");
 *     }
 *
 */