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

P粉602998670

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

681人浏览过

来源于php中文网

原创

答案是使用智能指针如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 obj = std::make_unique(arg1, arg2);
// 或者
std::shared_ptr obj = std::make_shared(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

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

易语言学习手册十天学会易语言图解教程 pdf版

十天学会易语言图解教程用图解的方式对易语言的使用方法和操作技巧作了生动、系统的讲解。需要的朋友们可以下载看看吧！全书分十章，分十天讲完。第一章是介绍易语言的安装，以及运行后的界面。同时介绍一个非常简单的小程序，以帮助用户入门学习。最后介绍编程的输入方法，以及一些初学者会遇到的常见问题。第二章将接触一些具体的问题，如怎样编写一个1+2等于几的程序，并了解变量的概念，变量的有效范围，数据类型等知识。其后，您将跟着本书，编写一个自己的MP3播放器，认识窗口、按钮、编辑框三个常用组件。以认识命令及事件子程序。第

下载

处理

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 
#include 
#include 

// 简单的内存清理函数
void myNewHandler() {
    std::cerr << "New handler invoked! Attempting to free some memory..." << std::endl;
    // 假设我们有一个全局的缓存，这里尝试清理它
    static std::vector 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;
}

这种