2

假设我正在做一些需要在抛出异常时进行清理的事情。

例如，假设我正在创建一个动态数组，并且我需要构造对象，但它们的构造函数可能会抛出异常：

size_t const n = 100;
T *const p = static_cast<T *>(operator new(sizeof(T) * n));
size_t i;
for (i = 0; i < n; ++i)
    new (&p[i]) T(1, 2, 3);      // Not exception-safe if T::T(T const &) throws!

我可以通过以下方式修复它catch (...) { ...; throw; }：

size_t const n = 100;
T *const p = static_cast<T *>(operator new(sizeof(T) * n));
size_t i;
try
{
    for (i = 0; i < n; ++i)
        new (&p[i]) T(1, 2, 3);
}
catch (...)
{
    while (i > 0)
        p[--i].~T();
    operator delete(p);
    throw;
}

或通过作用域析构函数：

size_t n = 100;
struct Guard
{
    T *p;
    size_t i;
    Guard(size_t n) : i(), p(static_cast<T *>(operator new(sizeof(T) * n))) { }
    ~Guard()
    {
        while (i > 0)
            p[--i].~T();
        operator delete(p);
    }
} guard(n);

for (guard.i = 0; guard.i < n; ++guard.i)
    new (&guard.p[guard.i]) T(1, 2, 3);

guard.i = 0;     // Successful... "commit" the changes
guard.p = NULL;  // or whatever is necessary to commit the changes

我应该在什么时候使用哪种技术，为什么？

（注意：这个例子只是为了展示两种技术之间的区别。我知道它不是完美的代码，所以请不要专注于这个特定的例子。这只是为了说明。）

4

2 回答 2

2

一般来说，我会说这是一个缩放和安全的问题。

问题有try/catch两个方面：

  • 安全问题：任何忽略catch（不知何故）无法清理的早期返回
  • 缩放问题：嵌套try/catch块弄乱了代码
  • 范围问题：catch必须在变量之前定义才能在变量中访问try，因此支持默认构造/可空性；可能很痛苦

相反，延迟语句和守卫不会创建不必要的块/范围，因此没有缩进，并且可以线性读取。

例子：

char buffer1[sizeof(T)];
try {
    new (buffer1) T(original);

    char buffer2[sizeof(T)];
    try {
        new (buffer2) T(original);

        // stuff here

    } catch(...) {
        reinterpret_cast<T*>(buffer2)->~T();
        throw;
    }

} catch(...) {
    reinterpret_cast<T*>(buffer1)->~T();
    throw;
}

相比：

char buffer1[sizeof(T)];
new (buffer1) T(original);
Defer const defer1{[&buffer1]() { reinterpret_cast<T*>(buffer1)->~T(); } };

char buffer2[sizeof(T)];
new (buffer2) T(original);
Defer const defer1{[&buffer2]() { reinterpret_cast<T*>(buffer2)->~T(); } };

// stuff here

我会注意到，概括这些似乎是个好主意：

class Guard {
public:
    explicit Guard(std::function<void()> f): _function(std::move(f)) {}

    Guard(Guard&&) = delete;
    Guard& operator=(Guard&&) = delete;

    Guard(Guard const&) = delete;
    Guard& operator=(Guard const&) = delete;

    ~Guard() {
        if (not _function) { return; }
        try { _function(); } catch(...) {}
    }

    void cancel() { _function = std::function<void()>{}; }

private:
    std::function<void()> _function;
}; // class Guard

class Defer {
public:
    explicit Defer(std::function<void()> f): _guard(std::move(f)) {}
private:
    Guard _guard;
}; // class Defer
于 2014-03-12T10:02:22.673 回答
2

使用析构函数的解决方案比显式的更好try/catch：

  • 它是可重用的，如果您需要在另一个函数中进行类似的初始化，您可以重用相同的保护类
  • 它更容易维护 - 假设在某些情况下，您的函数需要返回失败但不会引发异常。使用警卫类，它或多或少会自动处理
  • 它更干净，因为代码更加模块化
于 2014-03-12T09:57:51.393 回答