C++动态对象数组分配和释放注意事项

malloc

free

new[]

delete[]

new[]

delete[]

new[]

delete

std::vector

std::unique_ptr<T[]>

new[]

delete[]

delete

new[]

delete

#include <iostream>
#include <string>

class MyResource {
public:
    std::string name;
    MyResource(const std::string& n = "default") : name(n) {
        std::cout << "MyResource " << name << " constructed." << std::endl;
    }
    ~MyResource() {
        std::cout << "MyResource " << name << " destructed." << std::endl;
    }
};

void demonstrate_correct_usage() {
    std::cout << "--- Demonstrating correct usage ---" << std::endl;
    MyResource* resources = new MyResource[3]{MyResource("A"), MyResource("B"), MyResource("C")};
    // ... 使用资源 ...
    delete[] resources; // 确保所有析构函数被调用，然后释放内存
    std::cout << "--- Correct usage finished ---" << std::endl << std::endl;
}

void demonstrate_incorrect_usage() {
    std::cout << "--- Demonstrating incorrect usage (DO NOT DO THIS) ---" << std::endl;
    MyResource* resources = new MyResource[3]{MyResource("X"), MyResource("Y"), MyResource("Z")};
    // ... 使用资源 ...
    // delete resources; // 错误！只调用一个析构函数，可能导致堆损坏和内存泄漏
    // 这里为了演示，我们还是用正确的delete[]，但请记住delete是错误的
    delete[] resources;
    std::cout << "--- Incorrect usage finished ---" << std::endl << std::endl;
}

int main() {
    demonstrate_correct_usage();
    // demonstrate_incorrect_usage(); // 实际项目中不要运行这种错误代码
    return 0;
}

demonstrate_incorrect_usage

MyResource X destructed.

Y

Z

new MyObject[size]

MyObject

new[]

new[]

delete[]

try-catch

catch

std::unique_ptr<T[]>

std::unique_ptr<T[]>

std::make_unique<T[]>

#include <iostream>
#include <memory> // For std::unique_ptr
#include <stdexcept> // For std::runtime_error
#include <vector> // Also a good alternative

class CriticalResource {
public:
    int id_;
    CriticalResource(int id) : id_(id) {
        std::cout << "CriticalResource " << id_ << " constructed." << std::endl;
        if (id_ == 1) {
            // 模拟在构造第二个对象时发生异常
            // std::cout << "Simulating error during construction of CriticalResource " << id_ << std::endl;
            // throw std::runtime_error("Failed to initialize CriticalResource 1");
        }
    }
    ~CriticalResource() {
        std::cout << "CriticalResource " << id_ << " destructed." << std::endl;
    }
};

void manual_array_with_exception_risk() {
    std::cout << "--- Manual array with exception risk ---" << std::endl;
    CriticalResource* arr = nullptr;
    try {
        // 如果这里 CriticalResource(1) 抛出异常，CriticalResource(0) 将被泄漏
        arr = new CriticalResource[3]{CriticalResource(0), CriticalResource(1), CriticalResource(2)};
        // 假设这里有一些后续操作可能抛出异常
        // throw std::runtime_error("Some other error after array construction");
    } catch (const std::exception& e) {
        std::cerr << "Caught exception: " << e.what() << std::endl;
        // 如果 arr 已经部分构造，这里的 delete[] arr 可能会有问题，
        // 或者说，如果异常发生在 new CriticalResource[3] 内部，
        // C++ 运行时会负责清理已构造的元素，但如果异常发生在 *之后*，
        // 那么没有智能指针就容易忘记 delete[]。
        // 为了演示，这里假设 new 本身是成功的，但后续操作失败。
        // 实际情况更复杂，但智能指针能简化。
    }
    // 即使在 catch 块中处理了，也容易遗漏或出错
    // delete[] arr; // 如果 arr 是 nullptr，这是安全的，但如果不是，且没在catch中处理，就泄漏了
    std::cout << "--- Manual array finished ---" << std::endl << std::endl;
}

void smart_ptr_for_exception_safety() {
    std::cout << "--- Smart pointer for exception safety ---" << std::endl;
    try {
        // std::make_unique<T[]> 是 C++14 及更高版本推荐的创建方式
        // 它会负责调用 new T[size]
        auto arr_ptr = std::make_unique<CriticalResource[]>(3); // 调用 CriticalResource 的默认构造函数
        // 如果 CriticalResource 的构造函数会抛异常，new T[size] 会确保已构造的元素被正确析构
        // 这里的 arr_ptr 确保了无论后续代码是否抛出异常，delete[] 都会被调用。
        // 例如：
        // throw std::runtime_error("Another error after smart pointer array creation");
    } catch (const std::exception& e) {
        std::cerr << "Caught exception in smart_ptr_safety: " << e.what() << std::endl;
    }
    // arr_ptr 在这里离开作用域，自动调用 delete[]，无需手动管理
    std::cout << "--- Smart pointer finished ---" << std::endl << std::endl;
}

int main() {
    // manual_array_with_exception_risk(); // 运行这段代码时，请小心处理异常模拟
    smart_ptr_for_exception_safety();
    return 0;
}

std::unique_ptr<T[]>

new[]

delete[]

arrayPtr[size]

arrayPtr[-1]