malloc
malloc 是 C 标准库中的一个函数，用于动态分配内存。它的函数声明如下：
void* malloc(size_t size);
malloc 接受一个参数 size，表示要分配的内存块的大小（以字节为单位）。它会在堆上分配一个大小为 size 字节的连续内存块，并返回一个指向该内存块的指针。
如果内存分配成功，malloc 返回一个指向分配内存的指针。如果分配失败，则返回 NULL。
使用 malloc 的示例：
#include <stdio.h>
#include <stdlib.h>
int main() {
int *ptr;
int num_elements = 5;
// 分配包含 5 个整数的内存块
ptr = (int*)malloc(num_elements * sizeof(int));
if (ptr == NULL) {
printf("内存分配失败\\n");
return 1;
}
// 使用分配的内存
for (int i = 0; i < num_elements; i++) {
ptr[i] = i; // 为数组赋值
}
// 输出分配的内存
for (int i = 0; i < num_elements; i++) {
printf("%d ", ptr[i]); // 输出 0 1 2 3 4
}
// 释放内存
free(ptr);
return 0;
}
在上面的示例中，malloc 用于分配包含 5 个整数的内存块。之后，我们检查是否分配成功，然后使用该内存。最后，在不再需要时，使用 free 函数释放内存块。
realloc
realloc 是 C 标准库中的一个函数，用于重新分配先前分配的内存块的大小。其函数声明如下：
void* realloc(void* ptr, size_t size);
realloc 接受两个参数：
ptr：指向先前由malloc、calloc或realloc返回的内存块的指针。如果ptr是NULL，则realloc的行为类似于malloc，即分配新的内存块。size：重新分配内存块的新大小（以字节为单位）。
realloc 会尝试重新分配已分配内存块的大小为 size 字节，并返回一个指向重新分配后的内存块的指针。如果分配成功，返回的指针可能与先前的指针相同，也可能不同；如果分配失败，则返回 NULL。
使用 realloc 的示例：
#include <stdio.h>
#include <stdlib.h>
int main() {
int *ptr;
int num_elements = 5;
// 分配包含 5 个整数的内存块
ptr = (int*)malloc(num_elements * sizeof(int));
if (ptr == NULL) {
printf("内存分配失败\\n");
return 1;
}
// 使用分配的内存
for (int i = 0; i < num_elements; i++) {
ptr[i] = i; // 为数组赋值
}
// 输出分配的内存
for (int i = 0; i < num_elements; i++) {
printf("%d ", ptr[i]); // 输出 0 1 2 3 4
}
// 重新分配内存块的大小为 10 个整数
ptr = (int*)realloc(ptr, 10 * sizeof(int));
if (ptr == NULL) {
printf("内存重新分配失败\\n");
return 1;
}
// 输出重新分配后的内存
for (int i = 0; i < 10; i++) {
printf("%d ", ptr[i]); // 输出 0 1 2 3 4 0 0 0 0 0
}
// 释放内存
free(ptr);
return 0;
}
在上面的示例中，我们首先使用 malloc 分配了一个包含 5 个整数的内存块，然后使用 realloc 重新分配了大小为 10 个整数的内存块。注意，我们始终应该检查 realloc 是否返回了 NULL，以确保内存分配成功。
calloc
calloc 是 C 标准库中的一个函数，用于动态分配内存，并将分配的内存空间初始化为零。
其函数声明如下：
void* calloc(size_t num, size_t size);
calloc 接受两个参数：
num：要分配的元素个数。size：每个元素的大小（以字节为单位）。
calloc 会分配 num * size 个字节的内存，并返回一个指向该内存的指针。与 malloc 不同，calloc 在分配内存时会将其内容初始化为零。
如果内存分配成功，calloc 返回一个指向分配内存的指针。如果分配失败，则返回 NULL。
使用 calloc 的示例：
#include <stdio.h>
#include <stdlib.h>
int main() {
int *ptr;
int num_elements = 5;
// 分配包含 5 个整数的内存块，并将其初始化为零
ptr = (int*)calloc(num_elements, sizeof(int));
if (ptr == NULL) {
printf("内存分配失败\\n");
return 1;
}
// 使用分配的内存
for (int i = 0; i < num_elements; i++) {
printf("%d ", ptr[i]); // 输出 0 0 0 0 0
}
// 释放内存
free(ptr);
return 0;
}
在上面的示例中，calloc 用于分配包含 5 个整数的内存块，并将其初始化为零。之后，我们检查是否分配成功，然后使用该内存，最后在不再需要时释放该内存。
memalign
memalign 是 C 标准库中的一个函数，用于分配一块内存，并保证返回的指针地址满足特定的对齐要求。
其函数声明如下：
void* memalign(size_t alignment, size_t size);
memalign 接受两个参数：
alignment：所需的对齐字节数，必须是 2 的幂，并且是size_t的倍数。size：要分配的内存块的大小（以字节为单位）。
memalign 会尝试分配一块大小为 size 字节的内存，并且该内存的地址是 alignment 的倍数。如果成功，返回指向分配内存的指针；如果失败，返回 NULL。
使用 memalign 的示例：
#include <stdio.h>
#include <stdlib.h>
int main() {
void* ptr;
size_t alignment = 16; // 对齐要求为 16 字节
size_t size = 64; // 分配内存块的大小为 64 字节
// 分配满足对齐要求的内存块
ptr = memalign(alignment, size);
if (ptr == NULL) {
printf("内存分配失败\\n");
return 1;
}
printf("分配的内存地址: %p\\n", ptr);
// 释放内存
free(ptr);
return 0;
}
在上面的示例中，我们使用 memalign 分配了一块大小为 64 字节的内存，并保证其地址满足 16 字节的对齐要求。请注意，alignment 必须是 2 的幂，并且是 size_t 的倍数。
posix_memalign
posix_memalign 是一个 C 语言函数，用于分配一块内存，并保证返回的指针地址满足特定的对齐要求。它在 POSIX 标准中定义，通常用于需要特定内存对齐的场景。
其函数声明如下：
int posix_memalign(void **memptr, size_t alignment, size_t size);
posix_memalign 接受三个参数：
memptr：指向指针的指针，用于存储分配内存的地址。alignment：所需的对齐字节数，必须是size_t类型的倍数，并且是 2 的幂。size：要分配的内存块的大小（以字节为单位）。
posix_memalign 会尝试分配一块大小为 size 字节的内存，并且该内存的地址是 alignment 的倍数。如果成功，memptr 将指向分配的内存块，并返回 0；如果失败，则返回一个非零值。
使用 posix_memalign 的示例：
#include <stdio.h>
#include <stdlib.h>
int main() {
void* ptr;
size_t alignment = 16; // 对齐要求为 16 字节
size_t size = 64; // 分配内存块的大小为 64 字节
// 分配满足对齐要求的内存块
int result = posix_memalign(&ptr, alignment, size);
if (result != 0) {
printf("内存分配失败\\n");
return 1;
}
printf("分配的内存地址: %p\\n", ptr);
// 释放内存
free(ptr);
return 0;
}
在上面的示例中，我们使用 posix_memalign 分配了一块大小为 64 字节的内存，并保证其地址满足 16 字节的对齐要求。注意，alignment 必须是 size_t 类型的倍数，并且是 2 的幂。
free
free 是 C 标准库中的一个函数，用于释放由 malloc、calloc、realloc 或 posix_memalign 等函数分配的动态内存。
其函数声明如下：
void free(void *ptr);
free 接受一个参数 ptr，即要释放的内存块的指针。该指针必须是之前调用上述分配函数返回的指针之一，或者是 NULL。
调用 free(ptr) 会释放 ptr 指向的内存块，并使该内存块可用于后续的内存分配。在释放内存后，应该避免再次访问已经释放的内存，因为这样做可能导致未定义的行为或程序崩溃。
使用 free 的示例：
#include <stdio.h>
#include <stdlib.h>
int main() {
int *ptr;
ptr = (int*)malloc(sizeof(int)); // 分配内存块
if (ptr == NULL) {
printf("内存分配失败\\n");
return 1;
}
*ptr = 10; // 向内存块写入数据
printf("ptr 指向的值为: %d\\n", *ptr);
free(ptr); // 释放内存块
return 0;
}
在上面的示例中，我们使用 malloc 分配了一个整数大小的内存块，并将其地址存储在 ptr 指针中。然后，我们向该内存块写入了一个整数值，并使用 printf 输出该值。最后，我们使用 free 释放了分配的内存块，以确保不再使用该内存块。
参考
参考来源–chatgpt3.5，无法确保正确性，请注意甄别。