我正在根据 2018 年后的圣地亚哥草案 (N4791) 实现我自己的 vector ，并且有一些关于实现强异常安全性的问题。

这是一些代码:

template <typename T, typename Allocator>
void Vector<T, Allocator>::push_back(const T& value)
{
    if (buffer_capacity == 0)
    {
        this->Allocate(this->GetSufficientCapacity(1));
    }
    if (buffer_size < buffer_capacity)
    {
        this->Construct(value);
        return;
    }
    auto new_buffer = CreateNewBuffer(this->GetSufficientCapacity(
        buffer_size + 1), allocator);
    this->MoveAll(new_buffer);
    try
    {
        new_buffer.Construct(value);
    }
    catch (...)
    {
        this->Rollback(new_buffer, std::end(new_buffer));
        throw;
    }
    this->Commit(std::move(new_buffer));
}

template <typename T, typename Allocator>
void Vector<T, Allocator>::Allocate(size_type new_capacity)
{
    elements = std::allocator_traits<Allocator>::allocate(allocator,
        new_capacity);
    buffer_capacity = new_capacity;
}

template <typename T, typename Allocator> template <typename... Args>
void Vector<T, Allocator>::Construct(Args&&... args)
{
    // TODO: std::to_address
    std::allocator_traits<Allocator>::construct(allocator,
        elements + buffer_size, std::forward<Args>(args)...);
    ++buffer_size;
}

template <typename T, typename Allocator>
Vector<T, Allocator> Vector<T, Allocator>::CreateNewBuffer(
    size_type new_capacity, const Allocator& new_allocator)
{
    Vector new_buffer{new_allocator};
    new_buffer.Allocate(new_capacity);
    return new_buffer;
}

template <typename T, typename Allocator>
void Vector<T, Allocator>::Move(iterator first, iterator last, Vector& buffer)
{
    if (std::is_nothrow_move_constructible_v<T> ||
        !std::is_copy_constructible_v<T>)
    {
        std::move(first, last, std::back_inserter(buffer));
    }
    else
    {
        std::copy(first, last, std::back_inserter(buffer));
    }
}

template <typename T, typename Allocator
void Vector<T, Allocator>::MoveAll(Vector& buffer)
{
    Move(std::begin(*this), std::end(*this), buffer);
}

template <typename T, typename Allocator>
void Vector<T, Allocator>::Rollback(Vector& other, iterator last) noexcept
{
    if (!std::is_nothrow_move_constructible_v<T> &&
        std::is_copy_constructible_v<T>)
    {
        return;
    }
    std::move(std::begin(other), last, std::begin(*this));
}

template <typename T, typename Allocator>
void Vector<T, Allocator>::Commit(Vector&& other) noexcept
{
    this->Deallocate();
    elements = other.elements;
    buffer_capacity = other.buffer_capacity;
    buffer_size = other.buffer_size;
    allocator = other.allocator;
    other.elements = nullptr;
    other.buffer_capacity = 0;
    other.buffer_size = 0;
}

我发现此代码有 2 个问题。我试图遵循 std::move_if_noexcept 逻辑，但是如果元素不是可构造的，但是 allocator_traits::construct 抛出异常，比如说，一些日志代码在自定义分配器中？然后我的 MoveAll 调用将抛出并仅产生基本保证。这是标准的缺陷吗？ Allocator::construct 是否应该有更严格的措辞？

还有一个在Rollback 中。只有当被移动的元素不可抛出移动时，它才会真正产生强有力的保证。否则，再次，只有基本保证。这是应该的样子吗？

最佳答案

基于范围的std::move/copy函数无法提供强大的异常保证。如果出现异常，您需要一个迭代器指向成功复制/移动的最后一个元素，以便您可以正确地撤消操作。您必须手动执行复制/移动(或编写专门的函数来执行此操作)。

至于你的问题的细节，标准并没有真正解决如果 construct 会发生什么。发出一个异常，该异常不是从正在构造的对象的构造函数中抛出的。该标准的意图(出于我将在下面解释的原因)可能是这种情况永远不应该发生。但是我还没有在标准中找到关于此的任何声明。因此，让我们暂时假设这是有可能实现的。

为了让分配器感知容器能够提供强异常保证，construct至少不能在构造对象后 抛出。毕竟，你并不知道抛出的是什么异常，否则你无法判断这个对象是否构造成功。这将使实现标准要求的行为变得不可能。因此，让我们假设用户没有做任何导致无法实现的事情。

鉴于这种情况，您可以编写代码，假设 construct 发出的任何异常表示未构造对象。如果construct尽管给出了将调用 noexcept 的参数，但仍发出异常构造函数，那么您假设从未调用过构造函数。然后您相应地编写代码。

在复制的情况下，你只需要删除任何已经复制的元素(当然是相反的顺序)。移动案例有点棘手，但仍然很可行。您必须将每个成功移动的对象移动分配回其原始位置。

问题是什么？ vector<T>::*_back不需要 T可移动。它只需要 T可移动可插入:也就是说，您可以使用分配器在未初始化的内存中构造它们。但是您并没有将它移动到未初始化的内存中；你需要把它移到移出的地方 T已经存在。因此，要保留此要求，您需要销毁所有 T已成功移动的 s，然后将它们 MoveInsert 放回原位。

但是由于 MoveInsertion 需要使用 construct ，如前所述，它可能会抛出... oops。事实上，这正是 为什么 vector的重新分配函数不会移动，除非类型不可移动或不可复制(如果是后一种情况，您不会得到强异常保证)。

所以我很清楚任何分配器的 construct标准期望方法仅在所选构造函数抛出时抛出。没有其他方法可以在 vector 中实现所需的行为.但鉴于此要求没有明确声明，我会说这是标准中的一个缺陷。这不是一个新缺陷，因为我查看了 C++17 标准而不是工作文件。

显然这是一个 LWG issue since 2014 的主题，解决方法是……麻烦。

关于c++ - 实现 std::vector::push_back 强异常安全，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/54051349/