C++ RAII 管理对象状态的更改和恢复

Question

我有一堂课 foo。对 foo 的操作需要调用 foo::open()、多次 foo::write()，并且必须以 foo::close() 调用结束：

#include <iostream>

class foo
{
public:
    foo()
    {
        std::cout << "foo::foo()" << std::endl;
    }
    ~foo()
    {
        std::cout << "foo::~foo()" << std::endl;
    }    
    void open()
    {
        std::cout << "foo::open()" << std::endl;
    }
    void close()
    {
        std::cout << "foo::close()" << std::endl;
    }
    void write(const std::string& s)
    {
        std::cout << "foo::write(" << s << ")" << std::endl;
    }    
private:    
    // state that must be retained for entire lifetime of object
};

static void useFoo(foo& my_foo)
{
    my_foo.open();
    my_foo.write("string1");
    my_foo.write("string2");
    my_foo.close();
}

int main(  int argc, char* argv[] )
{
    foo my_foo;
    useFoo(my_foo);
    useFoo(my_foo);
}

正如预期的那样，这会输出以下内容：

foo::foo()
foo::open()
foo::write(string1)
foo::write(string2)
foo::close()
foo::open()
foo::write(string1)
foo::write(string2)
foo::close()
foo::~foo()

我想给用户我的类 foo 的一种方法是确保他们不会忘记调用 foo::close()，并确保在发生异常时调用 foo::close()。我无法使用 foo 的析构函数，因为 foo 必须在 foo::close() 之后继续存在，为下一个 foo::open() 做好准备。

我想出了这个 RAII 实现：

#include <iostream>

class foo
{
public:
    class opener
    {
    public:
        explicit opener(foo& my_foo):foo_(my_foo)
        {
            foo_.open();
        };
        ~opener()
        {
            foo_.close();
        };    
    private:
        foo& foo_;
    };    
    foo()
    {
        std::cout << "foo::foo()" << std::endl;
    }
    ~foo()
    {
        std::cout << "foo::~foo()" << std::endl;
    }    
    void open()
    {
        std::cout << "foo::open()" << std::endl;
    }
    void close()
    {
        std::cout << "foo::close()" << std::endl;
    }
    void write(const std::string& s)
    {
        std::cout << "foo::write(" << s << ")" << std::endl;
    } 
    opener get_opener()
    {
        return(opener(*this));
    }   
private:
    // state that must be retained for entire lifetime of object    
};


static void useFoo(foo& my_foo)
{
    foo::opener my_foo_opener = my_foo.get_opener();
    my_foo.write("string1");
    my_foo.write("string2");
}

int main(  int argc, char* argv[] )
{
    foo my_foo;
    useFoo(my_foo);
    useFoo(my_foo);
}

为了简单起见，我没有包括让 foo::opener 类公开 foo::write() 方法的明显改进，尽管在真实对象中我会这样做以防止写入() 在 open() 之前是可能的。

编辑 正如 Nawaz 在下面指出的那样，真正的类还需要复制构造函数和赋值运算符。

这似乎有很多样板只是为了确保调用 close() 。出现两个问题：

1. 这仍然比强制我的类的用户使用 try/catch 更简单吗？

2. 有没有更简单的方法来实现我想要的：提供基本的异常保证并确保 close() 始终遵循 open()？

Answer 1

嵌套类 opener 应该实现复制语义，因为如果我正确理解您的意图，编译器生成的默认代码将产生不良结果。

所以请实现复制构造函数和复制赋值。

或者，您可能希望通过将其声明¹ private 来完全禁用复制语义，就像所有标准流类的实现。我更喜欢这种方法。

^{1.请注意，您不需要定义它们。只需在 private 部分声明它们就足够了。}

Answer 2

close 会失败吗？如果可以，那么无论采用哪种方法，您都需要格外小心。我认为 RAII 方法比强制用户进行异常处理/关闭更简单。

foo 的创建和销毁真的如此复杂（还是全局的？）以至于您不能只让其析构函数调用 close 而不是使用 opener 来执行匹配的打开/关闭？

或者，如果这是实现某种事务语义，我看不到比 opener 类更简单的方法（但正如其他答案中所述，您可能希望禁用 opener 类的复制和分配）。

Answer 3

我认为你应该分开你的关注点：

• 一个类来存储整个类中携带的状态，
• 以处理打开/关闭中的瞬态状态，它还负责所有“瞬态”操作，例如写入

“瞬态”类需要“数据”类作为参数（通过引用）并将在各种方法调用期间更新它。

然后，您可以在瞬态类上使用典型的 RAII，并且仍然可以在整个类中传播状态。

Answer 4

这是使用 RAII 的经典案例。请使用构造函数和析构函数：如果您想再次open()，请实例化一个新的foo。 RAII 的思想是实例化代表单一资源使用。这就是您获得资源清理保证的方式。

struct foo {
    foo() { open(); }
    ~foo() { close(); }
    void write(const std::string& s);
private:  // or public
    foo(const foo&);
    foo& operator=(const foo&);
};

// ...
{ foo fooa;
    fooa.write("hello 0");
} { foo foob;
    foob.write("hello 1");
}

Answer 5

您可以向类添加一个标志，如果调用 open()，则设置为 true；如果调用 close()，则设置为 false。如果调用 open()，您可以检查该标志是 true 还是 false，并在继续之前关闭（如果需要）。