动态创建的范围保护

Question

我已阅读有关 DDJ 中范围保护 (Generic: Change the Way You Write Exception-Safe Code — Forever) 的文章，我了解它们的常见用途。

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

{
    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's blog on efficient movable value types

Answer 2

嗯，原来 DDJ 范围保护是“可移动的”，不是在 C++0x 的意义上，而是与 auto_ptr 是可移动的相同：在复制 ctor 期间，新的保护“解除”旧的保护（就像 auto_ptr 的复制 ctor 调用旧的 auto_ptr::release）。

所以我可以简单地保留一个queue<ScopeGuard>，它会起作用：

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));
   // ...
}

顺便谢谢你上面的回答。它以不同的方式为我提供了丰富的信息和教育。