是否使用多个签名的相同代码重载赋值运算符？

Question

假设我有一个C类：

class C {
    int m_i { 0 };
};

现在这个类可以用于非易失性对象和易失性对象：

C x;
volatile C y;

我希望能够分配易失性到非易失性，非易失性到易失性，非易失性到非易失性。所以我重载了C的赋值操作符：

class C {
    int m_i { 0 };
public:
    void operator=(const volatile C& source) volatile {
        m_i = source.m_i;
    }

    void operator=(const C& source) {
        m_i = source.m_i;
    }
};

这能否以一种干式的方式完成，而不需要重复operator=函数中的代码？

Answer 1

因此，在考虑了一段时间后，这是我能想到的最好的解决方案：

class C {
    int m_i { 0 };

    void assignFrom(const volatile C& src, const bool volatileSrc = true, const bool volatileSelf = true) volatile {
        auto& nqSrc = volatileSrc ? src : const_cast<const C&>(src);
        auto& self = volatileSelf ? *this : *const_cast<C*>(this);
        self.m_i = nqSrc.m_i;
    }

public:
    void operator=(const C& src) volatile {
        // non-volatile to volatile assignment
        assignFrom(src, false);
    }

    C& operator=(const volatile C& src) {
        // volatile to non-volatile assignment
        assignFrom(src, true, false);
        return *this;
    }

    C& operator=(const C& src) {
        // non-volatile to non-volatile assignment
        assignFrom(src, false, false);
        return *this;
    }
};

我测试了它，它似乎工作得很好。