3

我有一个功能，我希望有强大的异常保证：

class X {
   /* Fields and stuff */
   void some_function() {
       vector1.push_back(/*...*/); // May Throw
       vector2.push_back(/*...*/); // May Throw
       vector3.push_back(/*...*/); // May Throw
       vector4.push_back(/*...*/); // May Throw
   }
};

我能想到使其具有强大的异常保证的唯一方法如下：

class X {
   /* Fields and stuff */
   void some_function() {
       try { vector1.push_back(/*...*/);};
       catch (Vector1PushBackException) {
            throw Vector1PushBackException;
       }
       try { vector2.push_back(/*...*/);};
       catch (Vector2PushBackException) {
            vector1.pop_back();
            throw Vector2PushBackException;
       }
       try { vector3.push_back(/*...*/);};
       catch (Vector3PushBackException) {
            vector1.pop_back();
            vector2.pop_back();
            throw Vector3PushBackException;
       }
       try { vector4.push_back(/*...*/);};
       catch (Vector4PushBackException) {
            vector1.pop_back();
            vector2.pop_back();
            vector3.pop_back();
            throw Vector4PushBackException;
       }
   }
};

但是，这真的很丑陋且容易出错！有没有比我上面提到的更好的解决方案？我可以听到有人告诉我我需要使用 RAII，但我无法弄清楚如何使用，因为pop_back在函数正常返回时不能进行操作。

我也希望任何解决方案都是零 - 快乐道路上的开销；我真的需要尽可能快的快乐之路。

4

4 回答 4

2

解决方案是使用范围保护。

有关它们的示例实现，请参见此答案；我不打算在这里重复。使用范围保护，您的代码将如下所示：

vector1.push_back(/*...*/);
FINALLY_ON_THROW( vector1.pop_back(); )
vector2.push_back(/*...*/);
FINALLY_ON_THROW( vector2.pop_back(); )
vector3.push_back(/*...*/);
FINALLY_ON_THROW( vector3.pop_back(); )
vector4.push_back(/*...*/);
FINALLY_ON_THROW( vector4.pop_back(); )

这里，FINALLY_ON_THROW是一个宏（见上面的链接）。它不会立即执行它的参数，而是会在您因异常而离开当前范围时执行它。如果您以正常方式离开范围，则忽略该参数。如果您在控制权首先到达守卫之前离开范围，它也会被忽略。

请注意，如果最后一个守卫（在同一范围内）之后没有任何东西可以抛出，那么最后一个守卫是多余的。

于 2021-04-13T19:27:46.643 回答
2

简单地弹回的一个问题是它不一定会将向量恢复到原始状态。如果添加元素导致任何向量重新分配，则对元素的迭代器/引用将失效，并且该失效不能回滚，从而无法保证强异常。

一个安全、简单且通用的解决方案是对副本进行修改。复制当然需要额外的费用。

void some_function() {
    auto copy = *this;
    copy.vector1.push_back(/*...*/); // May Throw
    copy.vector2.push_back(/*...*/); // May Throw
    copy.vector3.push_back(/*...*/); // May Throw
    copy.vector4.push_back(/*...*/); // May Throw
    *this = std::move(copy);
}

在可能回滚的情况下， HolyBlackCat 的范围保护建议是一种优雅的解决方案，例如，如果您使用了另一个不会使迭代器/引用无效的容器，或者您根本不关心失效，或者您有一个阻止的类不变量当容量已满时调用该函数。

您可以切实可行地并以边际额外成本首先检查所有向量是否具有额外容量，然后根据检查在复制和回滚之间进行选择。这允许调用者在事先保留足够容量的情况下不支付复制成本。然而，这确实偏离了优雅。

于 2021-04-13T19:42:30.453 回答
1

您可以通过多种方式做到这一点......例如：

#include <vector>
#include <type_traits>
#include <exception>


template<class F>
struct on_fail
{
    F   f_;
    int count_{ std::uncaught_exceptions() };

    ~on_fail()
    {
        // C++20 is here and still no easy way to tell "unwinding" and "leaving scope" apart
        if (std::uncaught_exceptions() > count_) f_();
    }
};

template<class F> on_fail(F) -> on_fail<F>;


auto emplace_back_x(auto& v, auto&& x)
{
    v.emplace_back(std::forward<decltype(x)>(x));
    return on_fail{[&v]{ v.pop_back(); }};
}


int bar();


template<class F>
struct inplacer
{
    F f_;
    operator std::invoke_result_t<F&>() { return f_(); }
};

template<class F> inplacer(F) -> inplacer<F>;


void foo()
{
    std::vector<int> v1, v2, v3;
    auto rollback1 = emplace_back_x(v1, 1);
    auto rollback2 = emplace_back_x(v2, inplacer{ bar });
    auto rollback3 = emplace_back_x(v3, inplacer{ []{ return bar() + 1; } });
}

请注意，您的示例不正确：如果push_back()失败std::bad_alloc（或任何其他异常） - 您无法执行撤消步骤。

另外，在您的情况下，使用基本保证是否有意义？在实践中，您通常可以在更高级别上处理它 - 例如断开连接并丢弃整个累积状态，让客户端重新连接并重复尝试。

于 2021-04-13T20:18:39.320 回答
0

这个怎么样？

class X {
   /* Fields and stuff */
   void some_function() {
       vector1.push_back(/*...*/); // May Throw
       try {
           vector2.push_back(/*...*/); // May Throw
           try {
               vector3.push_back(/*...*/); // May Throw
               try {
                   vector4.push_back(/*...*/); // May Throw
               } catch(...) {
                   vector3.pop_back();
                   throw;
               }
           } catch(...) {
               vector2.pop_back();
               throw;
           }
       } catch(...) {
           vector1.pop_back();
           throw;
       }
   }
};

但是……你真的需要 4 个不同的向量吗？

class X {
   /* Fields and stuff */
   void some_function() {
       vector1234.push_back(std::make_tuple(/*...*/, /*...*/, /*...*/, /*...*/)); // May Throw
   }
};
于 2021-04-13T19:28:16.043 回答