C 操作内存主要函数－举例说明

１，void* malloc(size_t size);

#include <stdio.h>  
#include <stdlib.h>  
  
int main() {  
    int *ptr;  
    int num = 5;  
  
    // 使用 malloc() 分配内存  
    ptr = (int*) malloc(num * sizeof(int));  
  
    // 检查内存是否成功分配  
    if (ptr == NULL) {  
        printf("Memory allocation failed!\n");  
        return 1;  
    }  
  
    // 使用分配的内存  
    for (int i = 0; i < num; i++) {  
        ptr[i] = i + 1;  
    }  
  
    // 打印分配的内存中的值  
    for (int i = 0; i < num; i++) {  
        printf("%d ", ptr[i]);  
    }  
  
    // 释放分配的内存  
    free(ptr);  
    ptr = NULL;  
  
    return 0;  
}

        在上面的示例中，我们使用 malloc() 函数分配了足够的内存来存储一个整数数组。然后，我们使用分配的内存存储了一些值，并打印了这些值。最后，我们使用 free() 函数释放了分配的内存。这是一个简单的示例，展示了如何使用 malloc() 函数在堆上动态分配内存。

２，void* calloc(size_t num, size_t size);

#include <stdio.h>  
#include <stdlib.h>  
  
int main() {  
    int *ptr;  
    int num = 5;  
  
    // 使用 calloc() 分配内存并将它初始化为零  
    ptr = (int*) calloc(num, sizeof(int));  
  
    // 检查内存是否成功分配  
    if (ptr == NULL) {  
        printf("Memory allocation failed!\n");  
        return 1;  
    }  
  
    // 使用分配的内存  
    for (int i = 0; i < num; i++) {  
        ptr[i] = i + 1;  
    }  
  
    // 打印分配的内存中的值  
    for (int i = 0; i < num; i++) {  
        printf("%d ", ptr[i]);  
    }  
  
    // 释放分配的内存  
    free(ptr);  
    ptr = NULL;  
  
    return 0;  
}

        在上面的示例中，我们使用 calloc() 函数分配了足够的内存来存储一个整数数组，并将分配的内存初始化为零。然后，我们使用分配的内存存储了一些值，并打印了这些值。最后，我们使用 free() 函数释放了分配的内存。这个示例展示了如何使用 calloc() 函数在堆上动态分配内存并将其初始化为零。

３，void* realloc(void* ptr, size_t new_size);

#include <stdio.h>  
#include <stdlib.h>  
  
int main() {  
    int *ptr = NULL;  
    int num = 5;  
  
    // 使用 malloc() 分配内存  
    ptr = (int*) malloc(num * sizeof(int));  
  
    // 检查内存是否成功分配  
    if (ptr == NULL) {  
        printf("Memory allocation failed!\n");  
        return 1;  
    }  
  
    // 使用分配的内存  
    for (int i = 0; i < num; i++) {  
        ptr[i] = i + 1;  
    }  
  
    // 扩大内存大小为10，并使用 realloc() 函数调整内存大小  
    num = 10;  
    ptr = (int*) realloc(ptr, num * sizeof(int));  
  
    // 检查内存是否成功调整大小  
    if (ptr == NULL) {  
        printf("Memory reallocation failed!\n");  
        free(ptr);  
        return 1;  
    }  
  
    // 使用调整后的内存  
    for (int i = num; i < 10; i++) {  
        ptr[i] = i + 1;  
    }  
  
    // 打印调整后的内存中的值  
    for (int i = 0; i < 10; i++) {  
        printf("%d ", ptr[i]);  
    }  
  
    // 释放分配的内存  
    free(ptr);  
    ptr = NULL;  
  
    return 0;  
}

        在上面的示例中，我们首先使用 malloc() 函数分配了足够的内存来存储一个整数数组。然后，我们使用分配的内存存储了一些值。接着，我们使用 realloc() 函数将内存大小从5扩大到10，并使用调整后的内存存储更多的值。最后，我们使用 free() 函数释放了分配的内存。这个示例展示了如何使用 realloc() 函数调整已分配内存的大小。

４，void free(void* ptr); 

前面申请内存后，都是用此函数释放，所以这里不举例了。

５，void* memcpy(void* dest, const void* src, size_t n);

#include <stdio.h>  
#include <string.h>  
  
int main() {  
    char source[] = "Hello, World!";  
    char destination[20];  
  
    // 使用 memcpy() 复制字符串  
    memcpy(destination, source, strlen(source) + 1);  
  
    // 打印目标字符串  
    printf("Destination string: %s\n", destination);  
  
    return 0;  
}

        在上面的示例中，我们定义了一个源字符串 source 和一个目标字符串 destination。然后，我们使用 memcpy() 函数将源字符串复制到目标字符串中。注意，我们使用 strlen(source) + 1 来确定要复制的字节数，包括字符串的结束符 \0。最后，我们打印目标字符串，输出结果为 "Destination string: Hello, World!"。这个示例展示了如何使用 memcpy() 函数从源地址复制指定长度的字节到目标地址。

６，void* memset(void* s, int c, size_t n);

#include <stdio.h>  
#include <string.h>  
  
int main() {  
    char str[20] = "Hello, World!";  
  
    // 使用 memset() 将内存区域中的每个字节都设置为 0  
    memset(str, 0, sizeof(str));  
  
    // 打印设置后的内存区域  
    printf("Set string: %s\n", str);  
  
    return 0;  
}

        在上面的示例中，我们定义了一个字符串 str，然后使用 memset() 函数将 str 中的每个字节都设置为 0。最后，我们打印设置后的内存区域，输出结果为 "Set string: "，注意后面的字符串内容是空字符，因为我们将每个字节都设置为 0 了。这个示例展示了如何使用 memset() 函数将内存区域中的每个字节都设置为指定的值。

７，void* memmove(void* dest, const void* src, size_t n);

其中 dest 是目标地址，src 是源地址，n 是要复制的字节数。

下面是一个使用 memmove() 函数的示例：

#include <stdio.h>  
#include <string.h>  
  
int main() {  
    char src[10] = "Hello";  
    char dest[10];  
  
    // 将 src 字符串复制到 dest 字符串  
    memmove(dest, src, strlen(src) + 1);  
  
    // 打印 dest 字符串  
    printf("Destination string: %s\n", dest);  
  
    return 0;  
}

        在上面的示例中，我们定义了一个源字符串 src 和一个目标字符串 dest。然后，我们使用 memmove() 函数将 src 字符串复制到 dest 字符串中。注意，我们使用 strlen(src) + 1 来确定要复制的字节数，包括字符串的结束符 \0。最后，我们打印目标字符串，输出结果为 "Destination string: Hello"。这个示例展示了如何使用 memmove() 函数从源地址复制指定长度的字节到目标地址，即使源地址和目标地址重叠。

８，sizeof（）

sizeof 是一个运算符，不是函数，用于计算所占内存空间的大小，单位是字节。它可以用于计算常见数据类型的大小，例如：

• 对于 int 类型的数据，sizeof(int) 返回的是 4，因为 int 类型的数据在大多数系统上占 4 个字节。
• 对于 char 类型的数据，sizeof(char) 返回的是 1，因为 char 类型的数据在大多数系统上占 1 个字节。
• 对于数组，sizeof 可以返回整个数组的大小，单位是字节。例如，对于一个包含 5 个 int 类型元素的数组，sizeof(array) 返回的是 20，因为整个数组占 20 个字节。

以下是一个示例程序，演示了如何使用 sizeof 运算符来计算常见数据类型的大小：

#include <stdio.h>  
  
int main() {  
    int a = 2;  
    char b = '3';  
    short c = 2;  
    long long d = 2;  
    printf("Size of a: %zu\n", sizeof(a));  
    printf("Size of b: %zu\n", sizeof(b));  
    printf("Size of c: %zu\n", sizeof(c));  
    printf("Size of d: %zu\n", sizeof(d));  
    return 0;  
}

运行该程序将输出以下结果：

Size of a: 4  
Size of b: 1  
Size of c: 2  
Size of d: 8