在设计时未考虑异常安全的方法/类中提供强有力的保证

Question

我有一个设计问题。先说这段代码

struct Trial{
    const double a;
    Trial(double a_) : a(a_){}
};

int main(){
    Trial t1(1.);
    Trial t2(2.);
    t1 = t2;
}

不编译，因为Trial::operator= 不是由编译器默认构建的，因为Trial::a 是const。这非常明显。

现在重点是，代码优先

struct Trial{
    const double a;
    Trial(double a_) : a(a_){}
};

struct MyClass : private Trial{
    MyClass(double a_) : Trial(a_), i(0) {};
    void wannaBeStrongGuaranteeMemberFunction(){
        MyClass old(i);
        bool failed = true;
        //... try to perform operations here
        if(failed)
            *this = old;
    }
    unsigned int i;
};

int main(){
    MyClass m1(1.);
    m1.wannaBeStrongGuaranteeMemberFunction();
}

我需要为类的某些方法提供强大的异常安全性，该类派生自Trial。此类方法对无穷无尽的成​​员系列（示例中的i）执行一系列无穷无尽的操作，这使得“手动”恢复操作变得不切实际。因此，我决定最好复制整个类，如果出现任何问题，再将其复制回来。

小括号，代码只是一个例子。遗留的真实世界代码中的一切都复杂得多。 在此示例中，仅复制 i 就可以了，但在实际代码中并非如此。 此外，这些操作具有多个（且复杂的）执行路径，因此将它们“读取”为“事务”会很痛苦。 此外，我正在使用范围保护来实现这一点，因此可以在实际代码中正确管理异常。

当然整个事情没有编译，因为*this = old这一行。

您将如何解决问题/解决问题？

Answer 1

显而易见的答案是修改Trial，使其支持 任务也是。除此之外，如果你的唯一原因是 想支持任务就是提供强有力的保障， 你可以实现自己的赋值运算符，最好 私有的，它忽略了基类；因为你知道 两个基类将相同，无需分配 他们之间。

请注意，强保证通常涉及交换而不是 任务。这不会改变问题：你不能交换 Trial 的两个版本。你很可能有 类似：

class MyClass : private Trial
{
    class Protected
    {
        bool myCommitted;
        MyClass* myOwner;
        MyClass myInstance;
    public:
        MyClass( MyClass& owner )
            : myCommitted( false )
            , myOwner( &owner )
            , myInstance( owner )
        {
        }
        ~MyClass()
        {
            if ( myCommitted ) {
                myOwner->swap( myInstance );
            }
        }
        MyClass& instance() { return myInstance; }
        void commit() { myCommitted = true; }
    };

public:

    void protectedFunc()
    {
        Protected p( *this );
        p.instance().unprotecedVersionOfFunc();
        //  ...
        p.commit();
    }

任何异常都会使对象保持不变。 （你可以， 当然，颠倒逻辑，对this进行修改， 如果未提交则交换。）做事的优势 这样，您还将“撤消”内存中的任何更改 分配等

最后：你真的想在Trial 中使用一个 const 成员吗？ 实现这一点的通常方法是使a 非常量但私有，并且只提供一个吸气剂。这表示 Trial::a 实际上是 const，except 表示完整 任务。