异常安全vector实现 内存分配失败处理策略

处理内存分配失败时，std::vector必须保证强异常安全，即操作要么成功，要么不改变对象状态。1. 使用raii和临时缓冲区：在不修改原对象的前提下分配新内存，仅当新资源完全初始化后才提交更改，否则在catch块中释放新内存并保持原状。2. 允许bad_alloc向上传播：但必须确保原vector状态未被破坏，所有成员变量更新延迟至成功后执行。3. 目标为强异常安全：通过“先分配、再构造、最后提交”策略，结合try-catch保护元素构造过程，防止旧元素提前析构。4. 可采用临时对象+swap：将变更封装在临时vector中，成功后通过noexcept swap原子提交，确保强保证。5. 统一分配器异常行为：即使使用nothrow分配器，也应主动检查空指针并抛出bad_alloc以符合stl语义。6. 构造函数同样需保护：在初始化多个元素时，异常发生后需析构已构造对象并释放内存。总之，异常安全的核心是确保任何操作在异常下仍维持对象的合法状态。

在实现一个异常安全的

vector

std::vector

push_back

resize

insert

以下是处理内存分配失败的核心策略和实现要点：

1. 使用 RAII 和临时缓冲区隔离风险

在执行可能改变

vector

例如，在

push_back

• 不直接在原内存上操作。
• 先用

  allocator_traits::allocate

  登录后复制
  分配新内存。
• 使用

  try-catch

  登录后复制
  包裹元素拷贝/移动构造。
• 若构造失败，释放新内存，原

  vector

  登录后复制
  状态不变。
• 成功后再释放旧内存并更新指针。

void push_back(const T& value) {
    if (size() == capacity()) {
        size_t new_cap = capacity() ? capacity() * 2 : 1;
        T* new_data = alloc.allocate(new_cap);  // 可能抛出 bad_alloc

        try {
            // 在新内存中构造新元素
            ::new(static_cast<void*>(new_data + size())) T(value);
            // 复制原有元素
            for (size_t i = 0; i < size(); ++i) {
                ::new(static_cast<void*>(new_data + i)) T(data_[i]);
                data_[i].~T();
            }
        } catch (...) {
            // 构造失败：释放已分配的新内存
            alloc.deallocate(new_data, new_cap);
            throw;  // 异常继续传播
        }

        // 替换旧内存
        deallocate_old();  // 释放旧空间
        data_ = new_data;
        capacity_ = new_cap;
        ++size_;
    } else {
        ::new(static_cast<void*>(data_ + size_)) T(value);
        ++size_;
    }
}

2. 分配失败时的行为：让 bad_alloc 向上传播

C++ 中内存分配失败通常抛出

std::bad_alloc

但关键在于：在传播之前，不能破坏原

vector

这意味着：

琅琅配音

全能AI配音神器

208

查看详情

• 所有对原数据的修改必须延迟到新资源完全就绪之后。
• 原有元素不能提前析构。
• 指针、大小、容量等成员变量在确认成功前不得更新。

3. 异常安全的三大保证级别及实现目标

为了实现强异常安全，常用“copy-and-swap”或“two-phase allocation”模式。

4. 使用临时对象和 swap 实现强异常安全

一种更清晰的做法是将危险操作封装在临时对象中，成功后再通过

push_back

noexcept

但注意：这种方式效率较低，因为复制整个 vector。适用于调试或小对象，生产实现中更倾向于手动管理临时缓冲。

5. 分配器（Allocator）的异常行为控制

自定义分配器可以改变内存分配行为。例如：

• 某些分配器在失败时不抛异常，而是返回空指针（如

  swap

  登录后复制
  ）。
• 此时需检查返回指针是否为

  void push_back(const T& value) {
      auto temp = *this;              // 复制当前状态（可能失败）
      temp.grow();                    // 扩容并添加元素
      temp.emplace_back(value);       // 在副本中添加
      swap(temp);                     // 原子交换，不抛异常（若 swap 是 noexcept）
  }

  登录后复制
  。

new(std::nothrow)

即使分配器不抛异常，也应统一向上层抛出

nullptr

6. 构造函数中的异常安全特别注意

T* ptr = alloc.allocate(n);
if (!ptr) {
    throw std::bad_alloc{};  // 主动抛出，保持接口一致
}

bad_alloc

析构已构造的元素，再释放内存，最后抛出异常。

总结：关键处理策略

• 先分配，再构造，最后提交：避免在原地修改导致中间状态。
• 用 try-catch 保护构造过程：确保异常发生时清理临时资源。
• 不提前析构旧元素：直到新内存完全准备好。
• swap 是实现强异常安全的利器：结合临时对象使用。
• 允许 bad_alloc 向上传播：但必须保持对象一致性。

基本上就这些。异常安全的核心不是防止异常，而是确保异常发生时程序仍处于合法状态。对于 vector 这类容器，这一点尤为重要。

vector

vector(size_t n, const T& value, const Alloc& a = Alloc())
    : alloc(a), data_(nullptr), size_(0), capacity_(0)
{
    data_ = alloc.allocate(n);
    try {
        for (; size_ < n; ++size_) {
            ::new(static_cast<void*>(data_ + size_)) T(value);
        }
    } catch (...) {
        while (size_ > 0) {
            data_[--size_].~T();
        }
        alloc.deallocate(data_, n);
        throw;
    }
}

以上就是异常安全vector实现 内存分配失败处理策略的详细内容，更多请关注php中文网其它相关文章！