【C语言】一文搞懂malloc()、free()、new()、delete()

秒速五厘米 2024-03-17 13:09 61阅读 0赞

**目录**

malloc()

free()

new()

delete()

--------------------

## malloc() ##

\`malloc\`是C语言中的一个标准库函数，用于在堆（heap）上分配指定字节数的内存空间。它的函数原型如下：

void *malloc(size_t size);

该函数接受一个\`size\_t\`类型的参数\`size\`，表示要分配的字节数（即所需内存空间的大小）。它返回一个指向分配的内存空间的指针，如果分配失败，则返回\`NULL\`。

\`malloc\`函数动态地在堆上分配内存空间，这意味着分配的内存空间在程序运行时可用，并且不会受到局部变量的生命周期的限制。你可以使用指针来操作所分配的内存空间。

## free() ##

在C语言中，\`free\`是一个标准库函数，用于释放通过\`malloc\`、\`calloc\`或\`realloc\`等函数分配的内存空间。它的函数原型如下：

void free(void *ptr);

该函数接受一个指针参数\`ptr\`，该指针指向需要释放的内存空间。调用\`free\`函数后，该内存空间将返回给系统，可以被后续的内存分配使用。

以下是使用\`malloc\`和\`free\`函数动态分配和释放内存空间的示例：

#include <stdio.h>
    #include <stdlib.h>
    
    int main() {
        int size = 5;
        int *ptr = (int*) malloc(size * sizeof(int));
    
        if(ptr == NULL) {
            printf("内存分配失败\n");
            exit(1);
        }
    
        // 使用分配的内存空间
        for(int i = 0; i < size; i++) {
            ptr[i] = i + 1;
        }
    
        // 打印数组元素
        for(int i = 0; i < size; i++) {
            printf("%d ", ptr[i]);
        }
        printf("\n");
      
        // 释放内存空间
        free(ptr);
    
        return 0;
    }

在上述示例中，我们使用\`malloc\`函数分配了一个包含5个整数的数组所需的内存空间。然后，我们使用指针\`ptr\`对该数组进行操作和访问。最后，通过调用\`free\`函数释放内存空间，将分配的内存空间返回给系统。

需要注意的是，使用\`free\`函数释放的内存空间必须是通过\`malloc\`、\`calloc\`或\`realloc\`等函数动态分配的，并且指针参数\`ptr\`不能为\`NULL\`。如果给\`free\`传递了一个空指针或非法指针，可能会导致未定义的行为。另外，使用\`free\`释放内存空间后，不应再对已释放的内存进行访问，否则会出现无法预测的结果。

另外，C++中的内存释放应使用\`delete\`和\`delete\[\]\`，而不是\`free\`函数。对于通过\`new\`和\`new\[\]\`分配的内存，应使用相应的\`delete\`和\`delete\[\]\`来释放，以确保正确地调用对象的析构函数。

## new() ##

\`new\`是C++中的一个关键字，用于在堆上动态地分配内存空间并初始化对象。\`new\`与C语言中的\`malloc\`功能类似，但更为高级，它可以直接在内存空间上构造对象并返回对象的指针。

C++中使用\`new\`的基本语法如下：

new 类型名;
    new 类型名(初始化参数);

使用\`new\`可以分配单个对象的内存，例如：

int *p = new int;  // 分配一个int类型的内存空间，并将指针赋给p

也可以在分配内存的同时初始化对象，例如：

int *p = new int(10);  // 分配一个int类型的内存空间，并初始化为10，并将指针赋给p

除了分配单个对象的内存，\`new\`还可以分配多个对象的内存空间，例如：

int *arr = new int[5];  // 分配包含5个int类型元素的数组内存，并将指针赋给arr

使用\`new\`分配的内存空间在不需要时应该使用\`delete\`来释放，以避免内存泄漏，例如：

delete p;    // 释放p指向的int对象的内存空间
    delete[] arr;  // 释放arr指向的数组对象的内存空间

需要注意的是，\`new\`和\`delete\`是成对使用的。当使用\`new\`分配了内存后，应该通过\`delete\`来释放对应的内存。对于使用\`new\[\]\`分配的数组，应该使用\`delete\[\]\`来释放。

与\`malloc\`相比，\`new\`具有以下优势：

\- \`new\`可以直接在内存空间上构造对象，而不仅仅是分配内存；  
\- \`new\`为对象提供了初始化参数的功能，可以方便地对对象进行初始化；  
\- \`new\`和\`delete\`是与具体类型相关的，可以自动处理对象的构造和析构。

因此，在C++中，可以优先选择使用\`new\`和\`delete\`来进行动态内存的分配和释放，尤其是在使用类的对象时。但需要注意的是，C++中的\`new\`和\`delete\`不是标准库函数，而是C++关键字。

## delete() ##

在C++中，\`delete\`是一个关键字，用于释放通过\`new\`和\`new\[\]\`运算符动态分配的内存。它的使用形式如下：

delete 指针;

delete[] 指针;

\`delete\`关键字用于释放单个对象的内存空间，而\`delete\[\]\`关键字用于释放数组对象的内存空间。使用\`delete\`或\`delete\[\]\`时，要将指针作为参数传递给它们，指针指向需要释放的内存。

以下是使用\`new\`和\`delete\`动态分配和释放内存空间的示例：

#include <iostream>
    
    int main() {
        int* ptr = new int;  // 分配一个int类型的内存空间，并将指针赋给ptr
    
        *ptr = 10;  // 对动态分配的内存进行操作
    
        std::cout << *ptr << std::endl;  // 输出：10
    
        delete ptr;  // 释放ptr指向的int对象的内存空间
    
        return 0;
    }

在上述示例中，我们使用\`new\`运算符分配了一个\`int\`类型的内存空间，并将指针赋给\`ptr\`。然后，我们对分配的内存进行操作并输出结果。最后，通过使用\`delete\`关键字释放内存空间，将该内存空间返回给系统。

需要注意的是，使用\`delete\`或\`delete\[\]\`释放的内存空间必须是通过相应的\`new\`或\`new\[\]\`运算符动态分配的，并且指针参数不能为\`nullptr\`。使用\`delete\`释放了内存空间后，应该避免对已释放的内存进行访问，否则会导致未定义的行为。

对于数组对象的释放，使用\`delete\[\]\`而不是\`delete\`是非常重要的，因为\`delete\[\]\`会正确地调用数组对象的每个元素的析构函数。

总结来说，\`delete\`是C++中用于释放通过\`new\`动态分配的单个对象的内存空间，而\`delete\[\]\`用于释放通过\`new\[\]\`动态分配的数组对象的内存空间。通过使用\`delete\`和\`delete\[\]\`可以确保释放动态分配的内存，并正确调用对象的析构函数。