C/C++的内存管理，看这一篇就够了！_比较c与c++的内存管理-优快云博客

malloc 函数接受一个参数 size，该参数表示要分配的内存块的大小，以字节为单位。函数返回一个指向分配内存块的起始地址的指针，这个指针的类型是void*，因此需要显式类型转换来匹配你分配的数据类型。
如果 malloc 分配内存成功，它会返回一个指向新分配内存的指针。如果分配失败，它会返回一个空指针（NULL）。
内存块分配的位置通常在堆中，堆是程序运行时的动态内存分配区域，用于存储程序运行时需要的数据。
分配的内存块不会被初始化，它的内容是未定义的。你需要自行初始化内存块中的数据。
内存分配的大小必须是非负的，并且通常应该符合特定的对齐要求。

malloc 用于分配指定字节数的内存块，它在堆上分配内存。以下是其用法和示例：

#include <stdio.h>
#include <stdlib.h>

int main() {
    int *ptr;
    ptr = (int *)malloc(sizeof(int)); // 分配一个整数大小的内存块

    if (ptr == NULL) {
        printf("内存分配失败\n");
        return 1;
    }

    *ptr = 42; // 在分配的内存中存储数据
    printf("存储的值: %d\n", *ptr);

    free(ptr); // 释放内存
    return 0;
}

`calloc` 函数

calloc（Contiguous Allocation）函数是C标准库中的内存分配函数，用于在堆内存中分配一块指定数量和大小的内存区域，并将该内存区域的所有字节初始化为零。下面是对 calloc 函数的详细解释：

void* calloc(size_t num_elements, size_t element_size);

calloc 函数接受两个参数：
- num_elements：要分配的元素数量。
- element_size：每个元素的大小，以字节为单位。
函数返回一个指向分配内存块的起始地址的指针，这个指针的类型是 void*，因此需要显式类型转换来匹配你分配的数据类型。
如果分配内存成功，calloc 会将分配的内存块的所有字节初始化为零，即将内存块清零。如果分配失败，它会返回一个空指针（NULL）。
内存分配的位置通常在堆中，堆是程序运行时的动态内存分配区域，用于存储程序运行时需要的数据。
分配的内存块的总大小为 num_elements * element_size 字节。
calloc 函数通常用于分配数组或其他需要大量初始化为零的数据结构的内存。

calloc 用于分配指定数量和大小的内存块，并初始化为零。以下是其用法和示例：

#include <stdio.h>
#include <stdlib.h>

int main() {
    int *ptr;
    int n = 5; // 分配5个整数大小的内存块

    ptr = (int *)calloc(n, sizeof(int));

    if (ptr == NULL) {
        printf("内存分配失败\n");
        return 1;
    }

    for (int i = 0; i < n; i++) {
        printf("内存块 %d 值: %d\n", i, ptr[i]);
    }

    free(ptr);
    return 0;
}

`realloc` 函数

realloc 函数是C标准库中的一个内存重新分配函数，它用于修改先前分配的内存块的大小，通常用于动态调整内存需求。以下是对 realloc 函数的详细解释：

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

realloc 函数接受两个参数：
- ptr：一个指向之前通过 malloc、calloc 或 realloc 分配的内存块的指针。如果 ptr 为 NULL，realloc 的行为将等同于 malloc，即分配新的内存块。
- size：要重新分配的内存块的新大小，以字节数为单位。
函数返回一个指向重新分配后的内存块的指针。这个指针的类型是 void*，因此需要显式类型转换来匹配你分配的数据类型。
如果内存重新分配成功，realloc 会返回一个指向新分配内存的指针。如果分配失败，它会返回一个空指针（NULL）。在分配失败的情况下，原来的内存块仍然有效。
内存重新分配的位置通常在堆中，堆是程序运行时的动态内存分配区域，用于存储程序运行时需要的数据。
realloc 会尽量保留原内存块的内容，并将其复制到新分配的内存中。如果无法在原地扩展内存，它会分配新内存、复制数据，并释放原内存。
内存重新分配的大小必须是非负的，并通常应该符合特定的对齐要求。

realloc 用于重新分配已分配内存块的大小。以下是其用法和示例：

#include <stdio.h>
#include <stdlib.h>

int main() {
    int *ptr;
    int n = 5; // 分配5个整数大小的内存块

    ptr = (int *)malloc(n * sizeof(int));
    
    if (ptr == NULL) {
        printf("内存分配失败\n");
        return 1;
    }

    ptr = (int *)realloc(ptr, 10 * sizeof(int)); // 扩大内存块大小

    if (ptr == NULL) {
        printf("内存重新分配失败\n");
        return 1;
    }

    free(ptr);
    return 0;
}

`free` 函数

free 函数是C标准库中的内存释放函数，用于释放先前分配的内存块，以便它可以被系统重新使用或释放。以下是对 free 函数的详细解释：

void free(void* ptr);

free 函数接受一个参数 ptr，它是一个指向先前通过 malloc、calloc、realloc 或类似函数分配的内存块的指针。通过释放这个指针所指的内存块，程序可以将该内存块返回给系统，以便在需要时可以被重用或释放。
free 函数不返回任何值，它只释放指定内存块的资源。
内存释放的位置通常在堆中，堆是程序运行时的动态内存分配区域，用于存储程序运行时需要的数据。
调用 free 函数后，释放的内存块将被标记为可用，但它的内容不会被清零或删除。这意味着释放的内存块中的数据可能仍然存在，但不再受程序的控制。

free 用于释放先前分配的内存块，以便它可以被重新使用或释放。示例代码已在前面的示例中使用。

#include <stdio.h>
#include <stdlib.h>

int main() {
    int *ptr;
    size_t size = 5;

    // 分配一个包含5个整数的数组
    ptr = (int*)malloc(size * sizeof(int));

    if (ptr == NULL) {
        printf("内存分配失败\n");
        return 1;
    }

    // 使用分配的内存
    for (size_t i = 0; i < size; i++) {
        ptr[i] = i * 10;
    }

    // 释放内存
    free(ptr);

    // 现在 ptr 不再指向有效的内存块，访问它将导致未定义行为

    return 0;
}

C++ 的 `new` 和 `delete`

`new` 运算符

new 运算符是C++中的内存分配和对象构造运算符，用于在堆（heap）上动态分配内存以创建对象。以下是对 new 运算符的详细解释：

`new` 运算符的用法

在C++中，new 运算符用于分配内存并创建对象。其一般的语法如下：

new 数据类型;

数据类型 表示要分配内存的数据类型，可以是内置数据类型（如 int、double）或用户定义的类类型。
new 运算符返回一个指向分配内存的对象的指针，该指针的类型与数据类型匹配。
new 运算符自动调用对象的构造函数来初始化对象。如果是内置数据类型，初始化为默认值。
如果内存分配失败，new 运算符会引发 std::bad_alloc 异常。程序员可以使用异常处理机制来处理此异常。

new 运算符用于在堆上动态分配内存以创建对象，同时会调用对象的构造函数。以下是其用法和示例：

#include <iostream>

int main() {
    int *ptr = new int(42); // 创建一个整数对象并初始化为42
    std::cout << "存储的值: " << *ptr << std::endl;

    delete ptr; // 释放内存并调用析构函数
    return 0;
}

delete 运算符

delete 运算符是C++中的内存释放和对象析构运算符，用于释放先前通过 new 运算符动态分配的内存并调用对象的析构函数。以下是对 delete 运算符的详细解释：

在C++中，delete 运算符用于释放通过 new 运算符动态分配的内存，同时会调用对象的析构函数。其一般的语法如下：

delete 指针;

指针 表示要释放的内存块的指针，通常是通过 new 运算符返回的指针。
delete 运算符不返回任何值，它只释放指定内存块的资源。
在释放内存时，delete 运算符会调用对象的析构函数来清理对象的资源。这对于确保对象的资源正常释放非常重要。

delete 运算符用于释放先前分配的内存，并调用对象的析构函数。示例代码如下：

#include <iostream>

class MyClass {
public:
    MyClass(int val) : value(val) {
        std::cout << "MyClass constructor called with value " << value << std::endl;
    }

    ~MyClass() {
        std::cout << "MyClass destructor called with value " << value << std::endl;
    }

    void printValue() {
        std::cout << "Value: " << value << std::endl;
    }

private:
    int value;
};

int main() {
    // 使用 new 运算符动态分配一个 MyClass 对象
    MyClass *obj = new MyClass(42);

    // 使用对象的成员函数
    obj->printValue();

    // 使用 delete 运算符释放内存
    delete obj;

    return 0;
}

C语言与C++的内存管理的区别

内存管理是编程中一个重要的方面，它涉及到如何分配、使用和释放内存。在C和C++中，有不同的内存管理方法，这些方法在使用和性能方面有一些重要区别。下面将详细讨论C和C++的内存管理方法，包括它们的区别、各自的优缺点以及如何选择哪种方法。

区别：

C的内存管理：
- 手动内存管理：在C中，内存管理是完全手动的。程序员需要显式分配内存（如使用malloc、calloc等）和释放内存（使用free）。
- 不支持构造和析构函数：C没有面向对象的概念，因此没有对象的构造和析构函数。内存分配和释放不会自动调用对象的构造和析构。
- 较低级别的控制：C提供了较低级别的内存控制，允许程序员更灵活地操作内存，但也容易引入错误和泄漏。
C++的内存管理：
- 支持构造和析构函数：C++具有面向对象的特性，对象的构造和析构函数自动调用。这意味着对象的资源管理更容易，避免了资源泄漏。
- RAII（资源获取即初始化）：C++中推崇RAII的编程范式，通过对象的生命周期与资源管理的绑定，可以更轻松地管理资源，如内存、文件句柄等。
- 智能指针：C++提供了智能指针（如std::shared_ptr和std::unique_ptr），它们自动管理动态分配的内存，帮助避免内存泄漏。
- 高级别的抽象：C++提供了更高级别的抽象，允许程序员更专注于问题的解决，而不是内存管理细节。

优缺点：

C的内存管理：

优点：
- 更低级别的控制：允许程序员更精细地管理内存，适用于特定需求。
- 适用于嵌入式系统和操作系统开发：这些领域通常需要更精细的内存控制。
缺点：
- 容易引入错误：手动内存管理容易引入内存泄漏、悬空指针等问题。
- 需要更多代码：内存管理代码会增加程序的复杂性和代码量。

C++的内存管理：

优点：
- 更安全：对象的构造和析构函数确保资源管理正确，减少了资源泄漏的风险。
- 提高开发效率：使用高级别的抽象和标准库，编写更容易维护和理解的代码。
缺点：
- 对于某些特定需求，可能会引入一些性能开销。例如，智能指针可能会引入额外的引用计数操作。

如何选择：

根据项目需求：选择内存管理方法应根据项目的需求。对于嵌入式系统或性能关键应用，可能需要C的低级别控制。对于大多数应用程序，C++的高级别抽象可能更适合。
维护性和可读性：考虑代码的可维护性和可读性。C++的内存管理方法通常会使代码更清晰和易于维护。
团队技能：考虑开发团队的技能水平。如果团队更熟悉C或C++，则可能更容易选择适当的内存管理方法。
性能要求：对于高性能应用，可能需要在C++内存管理的某些方面进行微调，以避免不必要的性能开销。

总的来说，C和C++的内存管理方法在控制级别、安全性和开发效率方面存在差异。选择适当的方法取决于项目需求、团队技能和性能要求。在现代C++中，倾向于使用C++的内存管理方式，因为它提供更高级别的抽象和更安全的资源管理。但在某些情况下，C的低级别控制仍然是有价值的。