C++异常安全vector 内存分配失败处理

在C++中实现异常安全的vector需确保内存分配失败时不泄漏资源，关键是在修改状态前完成所有可能抛出异常的操作。1. 扩容时先用临时缓冲区分配新内存并复制元素，若构造异常则释放临时内存并保持原状态，实现强异常安全；2. 使用std::allocator配合RAII（如std::unique_ptr）管理资源，确保异常路径下自动清理；3. push_back等操作在扩容时先构造新元素再复制旧元素，异常时析构已构造对象并释放内存；4. 可选nothrow分配处理内存不足，但标准做法仍抛std::bad_alloc。核心是：所有资源获取和构造在状态提交前完成，否则回滚，保证基本或强异常安全。

在C++中实现异常安全的vector，尤其是在内存分配失败时，需要确保程序不会发生内存泄漏、资源损坏或未定义行为。当operator new抛出std::bad_alloc时，vector的操作必须保持基本异常安全（Basic Exception Safety）或更优的强异常安全（Strong Exception Safety）。

内存分配失败的场景

在vector中，以下操作可能触发内存分配：

• push_back
• resize
• reserve
• insert

这些操作通常需要分配新的缓冲区，复制或移动旧元素，然后释放旧缓冲区。如果在复制过程中某次new抛出异常（如内存不足），必须确保原有数据不被破坏。

异常安全的内存分配策略

为了保证异常安全，关键是在真正修改对象状态前，确保所有可能抛出异常的操作都已完成或被妥善处理。

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

template
void vector::reserve(size_t new_cap) {
    if (new_cap <= capacity_) return;
T* new_data = static_cast(::operator new(new_cap * sizeof(T)));
try {
    for (size_t i = 0; i < size_; ++i) {
        new(&new_data[i]) T(data_[i]); // 复制构造
    }
} catch (...) {
    ::operator delete(new_data);
    throw; // 异常继续传播，但vector状态未变
}

// 仅当复制成功后才释放旧内存
for (size_t i = 0; i < size_; ++i) {
    data_[i].~T();
}
::operator delete(data_);

data_ = new_data;
capacity_ = new_cap;

}

这个模式确保：如果复制构造抛出异常，原始数据仍完整，新分配的内存也被释放，vector保持原状态（强异常安全）。
2. 使用std::allocator处理资源

更现代的实现使用std::allocator或std::pmr::memory_resource，它们封装了分配逻辑，便于管理：

							

								
								

									Bandy AI
									
全球领先的电商设计Agent
								
								下载 
							
						
std::allocator alloc;
T* new_block = alloc.allocate(new_capacity);
配合std::uninitialized_copy或RAII包装器（如std::unique_ptr），可以自动清理异常路径下的资源。
push_back的异常安全实现
以push_back为例，展示如何保证异常安全：
void push_back(const T& value) {
    if (size_ == capacity_) {
        size_t new_cap = capacity_ ? capacity_ * 2 : 1;
        T* new_data = alloc_.allocate(new_cap);
    try {
        new(&new_data[size_]) T(value); // 先构造新元素
        for (size_t i = 0; i < size_; ++i) {
            new(&new_data[i]) T(std::move_if_noexcept(data_[i]));
        }
    } catch (...) {
        if (new_data[size_] 已构造)
            new_data[size_].~T();
        alloc_.deallocate(new_data, new_cap);
        throw;
    }

    // 成功后析构旧对象并释放
    for (size_t i = 0; i < size_; ++i) {
        data_[i].~T();
    }
    alloc_.deallocate(data_, capacity_);

    data_ = new_data;
    capacity_ = new_cap;
} else {
    new(&data_[size_]) T(value);
}
++size_;
}

这种实现确保：即使在构造新元素或复制旧元素时失败，原始vector内容不受影响。
nothrow分配与备用策略
某些场景下可尝试使用nothrow版本避免异常：
void* ptr = ::operator new(size, std::nothrow);
if (!ptr) {
    // 处理分配失败：抛出自定义异常、记录日志、尝试释放缓存等
}
但标准STL容器通常仍选择抛出std::bad_alloc，以便上层统一处理。
基本上就这些。关键是：在提交状态变更前，所有资源获取和对象构造必须成功；否则清理临时资源，保持原状态。这样就能实现真正异常安全的vector。不复杂但容易忽略细节。