【C/C++ API】C++内存分配和释放函数分析

malloc

malloc 是 C 标准库中的一个函数，用于动态分配内存。它的函数声明如下：

void* malloc(size_t size);

1
2

malloc 接受一个参数 size，表示要分配的内存块的大小（以字节为单位）。它会在堆上分配一个大小为 size 字节的连续内存块，并返回一个指向该内存块的指针。

如果内存分配成功，malloc 返回一个指向分配内存的指针。如果分配失败，则返回 NULL。

使用 malloc 的示例：

#include 
#include 

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;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

在上面的示例中，malloc 用于分配包含 5 个整数的内存块。之后，我们检查是否分配成功，然后使用该内存。最后，在不再需要时，使用 free 函数释放内存块。

realloc

realloc 是 C 标准库中的一个函数，用于重新分配先前分配的内存块的大小。其函数声明如下：

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

1
2

realloc 接受两个参数：

• ptr：指向先前由 malloc、calloc 或 realloc 返回的内存块的指针。如果 ptr 是 NULL，则 realloc 的行为类似于 malloc，即分配新的内存块。
• size：重新分配内存块的新大小（以字节为单位）。

realloc 会尝试重新分配已分配内存块的大小为 size 字节，并返回一个指向重新分配后的内存块的指针。如果分配成功，返回的指针可能与先前的指针相同，也可能不同；如果分配失败，则返回 NULL。

使用 realloc 的示例：

#include 
#include 

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;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

在上面的示例中，我们首先使用 malloc 分配了一个包含 5 个整数的内存块，然后使用 realloc 重新分配了大小为 10 个整数的内存块。注意，我们始终应该检查 realloc 是否返回了 NULL，以确保内存分配成功。

calloc

calloc 是 C 标准库中的一个函数，用于动态分配内存，并将分配的内存空间初始化为零。

其函数声明如下：

void* calloc(size_t num, size_t size);

1
2

calloc 接受两个参数：

• num：要分配的元素个数。
• size：每个元素的大小（以字节为单位）。

calloc 会分配 num * size 个字节的内存，并返回一个指向该内存的指针。与 malloc 不同，calloc 在分配内存时会将其内容初始化为零。

如果内存分配成功，calloc 返回一个指向分配内存的指针。如果分配失败，则返回 NULL。

使用 calloc 的示例：

#include 
#include 

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;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

在上面的示例中，calloc 用于分配包含 5 个整数的内存块，并将其初始化为零。之后，我们检查是否分配成功，然后使用该内存，最后在不再需要时释放该内存。

memalign

memalign 是 C 标准库中的一个函数，用于分配一块内存，并保证返回的指针地址满足特定的对齐要求。

其函数声明如下：

void* memalign(size_t alignment, size_t size);

1
2

memalign 接受两个参数：

• alignment：所需的对齐字节数，必须是 2 的幂，并且是 size_t 的倍数。
• size：要分配的内存块的大小（以字节为单位）。

memalign 会尝试分配一块大小为 size 字节的内存，并且该内存的地址是 alignment 的倍数。如果成功，返回指向分配内存的指针；如果失败，返回 NULL。

使用 memalign 的示例：

#include 
#include 

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;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

在上面的示例中，我们使用 memalign 分配了一块大小为 64 字节的内存，并保证其地址满足 16 字节的对齐要求。请注意，alignment 必须是 2 的幂，并且是 size_t 的倍数。

posix_memalign

posix_memalign 是一个 C 语言函数，用于分配一块内存，并保证返回的指针地址满足特定的对齐要求。它在 POSIX 标准中定义，通常用于需要特定内存对齐的场景。

其函数声明如下：

int posix_memalign(void **memptr, size_t alignment, size_t size);

1
2

posix_memalign 接受三个参数：

• memptr：指向指针的指针，用于存储分配内存的地址。
• alignment：所需的对齐字节数，必须是 size_t 类型的倍数，并且是 2 的幂。
• size：要分配的内存块的大小（以字节为单位）。

posix_memalign 会尝试分配一块大小为 size 字节的内存，并且该内存的地址是 alignment 的倍数。如果成功，memptr 将指向分配的内存块，并返回 0；如果失败，则返回一个非零值。

使用 posix_memalign 的示例：

#include 
#include 

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;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

在上面的示例中，我们使用 posix_memalign 分配了一块大小为 64 字节的内存，并保证其地址满足 16 字节的对齐要求。注意，alignment 必须是 size_t 类型的倍数，并且是 2 的幂。

free

free 是 C 标准库中的一个函数，用于释放由 malloc、calloc、realloc 或 posix_memalign 等函数分配的动态内存。

其函数声明如下：

void free(void *ptr);

1
2

free 接受一个参数 ptr，即要释放的内存块的指针。该指针必须是之前调用上述分配函数返回的指针之一，或者是 NULL。

调用 free(ptr) 会释放 ptr 指向的内存块，并使该内存块可用于后续的内存分配。在释放内存后，应该避免再次访问已经释放的内存，因为这样做可能导致未定义的行为或程序崩溃。

使用 free 的示例：

#include 
#include 

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;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

在上面的示例中，我们使用 malloc 分配了一个整数大小的内存块，并将其地址存储在 ptr 指针中。然后，我们向该内存块写入了一个整数值，并使用 printf 输出该值。最后，我们使用 free 释放了分配的内存块，以确保不再使用该内存块。

参考

参考来源–chatgpt3.5，无法确保正确性，请注意甄别。