在C++中，delete 和 delete[] 是用于释放动态分配的内存的关键字。它们的使用取决于内存是如何分配的。具体来说：

1. delete 用于释放通过 new 分配的单个对象。
2. delete[] 用于释放通过 new[] 分配的数组。

如果你通过 new 分配了一个单个对象，那么你必须使用 delete 来释放它。如果你通过 new[] 分配了一个数组，那么你必须使用 delete[] 来释放它。

示例和解释

使用 new 和 delete

当你分配一个单个对象时，使用 new 和 delete：

#include <iostream>

int main() {
    // 分配一个整数
    int* p = new int(42);
    std::cout << "Value: " << *p << std::endl;

    // 释放分配的内存
    delete p;

    return 0;
}

在这种情况下，使用 delete 来释放通过 new 分配的内存。

使用 new[] 和 delete[]

当你分配一个数组时，使用 new[] 和 delete[]：

#include <iostream>

int main() {
    // 分配一个包含 10 个整数的数组
    int* arr = new int[10];

    // 初始化数组
    for (int i = 0; i < 10; ++i) {
        arr[i] = i;
        std::cout << arr[i] << " ";
    }
    std::cout << std::endl;

    // 释放分配的数组
    delete[] arr;

    return 0;
}

在这种情况下，使用 delete[] 来释放通过 new[] 分配的内存。

为什么一定要使用 delete[] 来释放数组

使用 delete 释放通过 new[] 分配的内存会导致未定义行为。这是因为 new[] 和 delete[] 知道它们处理的是一个数组，并会调用每个数组元素的析构函数（如果有）。而 delete 只会调用单个对象的析构函数。

示例：未定义行为

以下示例展示了错误的内存释放方式，这将导致未定义行为：

#include <iostream>

int main() {
    // 分配一个包含 10 个整数的数组
    int* arr = new int[10];

    // 错误地使用 delete 而不是 delete[]
    delete arr;  // 未定义行为

    return 0;
}

由于 delete 不能正确处理数组的内存释放，这会导致程序崩溃或其他不可预测的行为。

使用智能指针管理内存

现代 C++ 推荐使用智能指针（如 std::unique_ptr 和 std::shared_ptr）来自动管理内存，避免手动调用 delete 和 delete[]。

#include <iostream>
#include <memory>

int main() {
    // 使用 unique_ptr 自动管理单个对象
    std::unique_ptr<int> p(new int(42));
    std::cout << "Value: " << *p << std::endl;

    // 使用 unique_ptr 自动管理数组
    std::unique_ptr<int[]> arr(new int[10]);
    for (int i = 0; i < 10; ++i) {
        arr[i] = i;
        std::cout << arr[i] << " ";
    }
    std::cout << std::endl;

    return 0;
} // 在离开作用域时，p 和 arr 会自动释放所管理的内存

智能指针自动管理内存，可以避免内存泄漏和未定义行为问题。

总结

• 使用 delete 释放通过 new 分配的单个对象。
• 使用 delete[] 释放通过 new[] 分配的数组。
• 错误地使用 delete 来释放数组会导致未定义行为。
• 智能指针（如 std::unique_ptr 和 std::shared_ptr）可以自动管理内存，减少手动调用 delete 和 delete[] 的需求。