c++ - 有没有办法将所有赋值运算符(+=、*= 等)转发为隐式使用覆盖的直接赋值运算符 (=)？

Question

我知道“转发”在 C++11 中是一个不相关的概念(如“完美转发”)，但它是我描述问题时想到的第一个词。

我正在覆盖 operator=在包装类中 Proxy ,

template<typename T>
class Proxy
{
public:
    enum class State
    {
        NEVER_SET = 0,
        SET
    };
    operator const T& () const
    {
        if ( _state != State::SET )
        {
            throw std::domain_error{ "using unset data" };
        }
        return _data;
    }
    Proxy<T>& operator=(const T& val)
    {
        _data = val;
        _state = State::SET;
        return (*this);
    }
private:
    T _data;
    State _state = State::NEVER_SET;
};

但发现自己还需要补充:

    Proxy<T>& operator+=(const T& val)
    {
        _data = (*this) + val;
        _state = State::SET;
        return (*this);
    }
    Proxy<T>& operator-=(const T& val)
    {
        _data = (*this) - val;
        _state = State::SET;
        return (*this);
    }
    Proxy<T>& operator*=(const T& val)
    {
        _data = (*this) * val;
        _state = State::SET;
        return (*this);
    }
    Proxy<T>& operator/=(const T& val)
    {
        _data = (*this) / val;
        _state = State::SET;
        return (*this);
    }
    // ...and so on.

是否有“转发”所有赋值运算符的技巧(+=、-=、*=、/=、%=、>>=、<<=、|=、7|91545| , &= ) 以便我不必定义它们？也就是一种制作方法

Proxy<double> x = 7;
Proxy<double> y = 43;
x += y;

自动“解开”到

Proxy<double> x = 7;
Proxy<double> y = 43;
x = x + y; // cast operator converts x and y to double, then direct assigns sum,
           // therefore no += needing definition in Proxy<T>

Answer 1

您可以使用 CRTP，但如果您的目标是在您的 Proxy 类中只有一个显式 =，您将需要提供一些对其他运算符已经可用的类型的访问。换句话说，如果您定义了如何分配但没有定义如何添加，则不能说 a1 = a2 + a3。我在下面通过期望一个公开一些可以操作的状态的 get() 函数来解决这个问题。明确定义例如更典型(并且可能实用) += 然后根据它定义 +....

#include <iostream>

template <typename T>
struct Implied_Ops
{
    T operator+(const T& rhs) const
    {
        return rhs.get() + static_cast<const T*>(this)->get();
    }

    T& operator+=(const T& rhs)
    {
        return static_cast<T&>(*this) = operator+(rhs);
    }
};

struct X : Implied_Ops<X>
{
    X(int n) : n_(n) { }
    X& operator=(const X& rhs) { n_ = rhs.n_; return *this; }
    int get() const { return n_; }
    int n_;
};

int main()
{
    X x { 10 };
    X x2 = x + x;
    X x3 = x + x2;
    std::cout << x.n_ << ' ' << x2.n_ << ' ' << x3.n_ << '\n';
}

另一种不容忽视的方法是宏....