动态创建的范围防护

Question

我读过有关作用域保护的文章（通用：永远改变编写异常安全代码的方式< /a>) 在 DDJ 中，我了解它们的常见用途。

然而，常见的用途是在堆栈上实例化特定操作的特定堆栈保护，例如：

{
    FILE* topSecret = fopen("cia.txt");
    ON_BLOCK_EXIT(std::fclose, topSecret);
    ... use topSecret ...
} // topSecret automagically closed

但是如果我想在运行时安排清理操作，例如当我有循环时怎么办：

{
   vector<FILE*> topSecretFiles;
   for (int i=0; i<numberOfFiles; ++i)
   {
      char filename[256];
      sprintf(filename, "cia%d.txt", i);
      FILE* topSecret = fopen(filename);
      topSecretFiles.push_back(topSecret);
      ON_BLOCK_EXIT(std::fclose, topSecret); // no good
   }
}

显然，上面的示例不起作用，因为 topSecret 将与 for 范围一起关闭。我想要一个范围保护模式，我可以轻松地将我确定在运行时需要的清理操作排队。有这样的东西可用吗？

我无法将范围保护对象推送到标准队列中，因为原始对象（我正在推送的对象）将在此过程中被忽略。推送堆分配的堆栈防护并使用删除 dtor 上其成员的队列怎么样？有谁有更聪明的方法吗？

Answer 1

看来您并不欣赏 RAII 的本质。这些范围保护有时对于本地（“范围”）事物很有用，但您应该尽量避免使用它们，以支持 RAII 真正应该做的事情：将资源封装在对象中。 FILE* 类型确实不擅长于此。

这是一个替代方案：

void foo() {
    typedef std::tr1::shared_ptr<FILE> file_sptr;
    vector<file_sptr> bar;
    for (...) {
        file_sptr fsp ( std::fopen(...), std::fclose );
        bar.push_back(fsp);
    }
}

或者：

void foo() {
    typedef std::tr1::shared_ptr<std::fstream> stream_sptr;
    vector<stream_sptr> bar;
    for (...) {
        file_sptr fsp ( new std::fstream(...) );
        bar.push_back(fsp);
    }
}

或者在“C++0x”（即将推出的 C++ 标准）中：

void foo() {
    vector<std::fstream> bar;
    for (...) {
        // streams will become "movable"
        bar.push_back( std::fstream(...) );
    }
}

编辑：因为我非常喜欢 C++0x 中的可移动类型，并且您对它表现出了兴趣：以下是如何将 unique_ptr 与FILE* 没有任何引用计数开销：（

struct file_closer {
    void operator()(FILE* f) const { if (f) std::fclose(f); }
};

typedef std::unique_ptr<FILE,file_closer> file_handle;

file_handle source() {
    file_handle fh ( std::fopen(...) );
    return fh;
}

int sink(file_handle fh) {
    return std::fgetc( fh.get() );
}

int main() {
    return sink( source() );
}

未经测试）

请务必查看 Dave 关于高效可移动价值类型的博客

Answer 2

呵呵，原来 DDJ 作用域守卫是“可移动的”，不是 C++0x 意义上的，而是与 auto_ptr 是可移动的相同的意义：在复制过程中，新守卫“解雇”旧守卫（就像 auto_ptr 的复制构造函数调用旧构造函数的auto_ptr::release）。

所以我可以简单地保留一个队列，它就会起作用：

queue<ScopeGuard> scopeGuards;

// ...

for (...)
{
   // the temporary scopeguard is being neutralized when copied into the queue,
   // so it won't cause a double call of cleanupFunc
   scopeGuards.push_back(MakeScopeGuard(cleanupFunc, arg1));
   // ...
}

顺便说一句，谢谢您上面的回答。它以不同的方式对我提供了信息和教育。