C++new操作符异常安全使用方法-C++-PHP中文网

C++new操作符异常安全使用方法

P粉602998670

发布： 2025-09-20 16:16:01

原创

672人浏览过

答案是使用智能指针如std::unique_ptr和std::make_unique可确保异常安全。核心在于RAII原则，当new分配内存后构造函数抛出异常时，传统裸指针会导致内存泄漏，而std::make_unique在创建对象时将内存分配与资源管理绑定，若构造失败，其内部机制会自动释放已分配内存，避免泄漏。相比之下，try-catch仅能捕获bad_alloc，无法覆盖构造异常；std::nothrow不抛异常但返回nullptr，仍需手动管理资源且不解决构造异常问题。因此，推荐统一采用std::make_unique或std::make_shared，确保任何异常情况下资源都能正确释放，实现强异常安全保证。

c++new操作符异常安全使用方法

C++中

new

登录后复制

操作符的异常安全使用方法，核心在于遵循RAII（Resource Acquisition Is Initialization）原则，并善用C++标准库提供的工具，特别是智能指针。这确保了即使在内存分配失败或对象构造函数抛出异常时，已分配的资源也能被妥善管理，避免内存泄漏或程序状态不一致。

要真正做到

new

登录后复制

操作符的异常安全，我们不能仅仅依赖

try-catch

登录后复制

块来捕获

std::bad_alloc

登录后复制

。那只是冰山一角。更深层次的考量在于，即使内存分配成功，但随后的对象构造过程抛出异常，这块已分配但未完全构造的内存也必须被妥善释放。这就是为什么裸指针和手动

delete

登录后复制

在这种场景下极易出错。

最直接、最推荐的解决方案是全面拥抱智能指针。

std::unique_ptr

登录后复制

和

std::shared_ptr

登录后复制

是C++标准库为我们提供的强大工具，它们完美地封装了RAII范式。当你使用

std::make_unique

登录后复制

或

std::make_shared

登录后复制

来创建对象时，它们不仅负责内存的分配，更重要的是，它们确保了在任何阶段（包括构造函数抛出异常）都能正确地清理资源。

例如，考虑这样的场景：

立即学习“C++免费学习笔记（深入）”；

// 传统但有风险的写法
MyClass* obj = new MyClass(arg1, arg2); // 如果MyClass构造函数抛异常，这里就泄露了
// ... 使用obj ...
delete obj; // 如果上面代码在delete前抛异常，这里也泄露了

登录后复制

而使用智能指针则完全不同：

// 推荐的异常安全写法
std::unique_ptr<MyClass> obj = std::make_unique<MyClass>(arg1, arg2);
// 或者
std::shared_ptr<MyClass> obj = std::make_shared<MyClass>(arg1, arg2);

// ... 使用obj ...
// 无需手动delete，obj超出作用域时会自动释放

登录后复制

std::make_unique

登录后复制

和

std::make_shared

登录后复制

在内部处理了

new

登录后复制

的调用，并将其结果立即封装进智能指针。即使

MyClass

登录后复制

的构造函数抛出异常，智能指针的析构函数（或者说，

make_unique

登录后复制

make_shared

登录后复制

内部的机制）也会确保已分配的内存被释放，从而避免内存泄漏。

另一个值得一提的是

std::nothrow

登录后复制

版本。当你明确不希望

new

登录后复制

在内存不足时抛出

std::bad_alloc

登录后复制

，而是返回

nullptr

登录后复制

时，可以使用它：

MyClass* obj = new (std::nothrow) MyClass();
if (obj == nullptr) {
    // 处理内存分配失败的情况，例如记录日志、返回错误码等
    // 注意：这里仅处理了分配失败，构造函数异常仍会抛出
} else {
    // ... 使用obj ...
    delete obj;
}

登录后复制

但请注意，

std::nothrow

登录后复制

只影响内存分配失败时的行为，不影响对象构造函数抛出异常。如果

MyClass

登录后复制

的构造函数抛出异常，即使使用了

std::nothrow

登录后复制

，异常仍然会传播，并且此时已分配的内存需要手动或通过其他机制（如RAII）来清理。所以，

std::nothrow

登录后复制

通常只在非常特定的、对异常处理有严格限制的场景下才使用，并且仍需结合其他异常安全策略。

总的来说，智能指针是实现

new

登录后复制

操作符异常安全的首选和最佳实践。它们将资源管理与对象生命周期绑定，极大地简化了代码并提高了健壮性。

new操作符抛出std::bad_alloc异常时如何优雅地处理？

当

new

登录后复制

操作符无法分配请求的内存时，它默认会抛出

std::bad_alloc

登录后复制

异常。这是一种标准行为，表明系统资源已耗尽。对于我们开发者来说，捕获并处理这种异常是确保程序健壮性的关键一环，尤其是在内存敏感或长时间运行的服务中。

法语写作助手

法语助手旗下的AI智能写作平台，支持语法、拼写自动纠错，一键改写、润色你的法语作文。

查看详情

处理

std::bad_alloc

登录后复制

通常有几种策略。最直接的方式是使用

try-catch

登录后复制

块：

try {
    // 尝试分配一个非常大的数组，模拟内存不足
    int* largeArray = new int[1024 * 1024 * 1024]; // 假设这需要4GB内存
    // ... 使用largeArray ...
    delete[] largeArray;
} catch (const std::bad_alloc& e) {
    std::cerr << "内存分配失败: " << e.what() << std::endl;
    // 这里可以进行错误日志记录、通知用户、尝试释放一些缓存、
    // 或者优雅地关闭程序。
    // 例如，如果在一个服务器应用中，可能需要返回一个错误响应，
    // 或者尝试重启某个子模块。
}

登录后复制

这种方式的优点是清晰明了，能精确地知道是内存分配出了问题。但缺点是，它只能处理

new

登录后复制

本身抛出的异常，对于后续的构造函数异常则无能为力。而且，频繁地在每个

new

登录后复制

操作周围放置

try-catch

登录后复制

块会使代码变得臃肿且难以维护。

因此，更“优雅”的处理方式往往不是在每个

new

登录后复制

点都捕获，而是将这种资源耗尽的错误向上层传播，让更高层次的逻辑来决定如何应对。例如，一个大型应用程序可能会有一个全局的异常处理器，或者在关键的服务入口点捕获这类致命异常。

此外，我们还可以通过

std::set_new_handler

登录后复制

来自定义

new

登录后复制

失败时的行为。当

new

登录后复制

操作符无法分配内存时，在抛出

std::bad_alloc

登录后复制

之前，它会尝试调用一个由

std::set_new_handler

登录后复制

设置的函数。这个函数可以尝试释放一些内存，例如清理缓存，然后返回，让

new

登录后复制

再次尝试分配。如果这个函数也无法解决问题，它应该抛出异常（比如

std::bad_alloc

登录后复制

）或者调用

std::abort()

登录后复制

。

#include <new>
#include <iostream>
#include <vector>

// 简单的内存清理函数
void myNewHandler() {
    std::cerr << "New handler invoked! Attempting to free some memory..." << std::endl;
    // 假设我们有一个全局的缓存，这里尝试清理它
    static std::vector<char> largeCache(1024 * 1024 * 100); // 100MB
    largeCache.clear(); // 释放一些内存
    largeCache.shrink_to_fit();
    std::cerr << "Cache cleared. Retrying allocation." << std::endl;
    // 如果这里不抛异常，new会再次尝试分配
    // 如果仍然失败，new handler会再次被调用
    // 如果想立即终止，可以 throw std::bad_alloc() 或 std::abort()
}

int main() {
    std::set_new_handler(myNewHandler);

    try {
        // 尝试分配一个非常大的数组
        int* reallyLargeArray = new int[1024 * 1024 * 1024 * 4]; // 4GB
        std::cout << "Successfully allocated really large array." << std::endl;
        delete[] reallyLargeArray;
    } catch (const std::bad_alloc& e) {
        std::cerr << "Main catch block: " << e.what() << std::endl;
    }

    return 0;
}

登录后复制

这种