检测重载 C++ 运算符中的自赋值

Question

如果这是重复的，请原谅我；我搜索了，但正确的白话可能超出了我的理解范围。

我对一些任意类和重载运算符的目标

x = x op y

会认识到它是自分配的，而不是直接生成一个临时变量 op= 到 x （我不只是想重载 op=）。有没有办法做到这一点？

Answer 1

一种方法是让A op A 的操作返回另一个类APlusA 的临时对象，而不执行操作本身。此类有一个到A 的转换运算符，可在需要时执行实际计算。

诀窍是在类A 中实现operator= 的一个版本，它采用APlusA 的临时对象。如果它识别出它正在对同一个对象进行操作，则它可以就地执行操作，而无需创建临时的A 对象。这是一个示例 (test on ideone)：

#include <iostream>

struct A {
    struct APlusA {
        APlusA(const A&a_, const A&b_) : a(a_), b(b_) {}
        const A &a;
        const A &b;

        operator A() const { 
            std::cout << "Creating temporary A" << std::endl; 
            return A(a.val + b.val);
        }
    };

    A(int val_) : val(val_) {}
    friend APlusA operator+(const A&a, const A&b) { return APlusA(a,b); }
    friend std::ostream &operator<<(std::ostream &s, const A &a) { return s << a.val;}

    A& operator=(const APlusA &apa) {
        if (this == &apa.a) {
            std::cout << "Performing in-place operation" << std::endl;
            val += apa.b.val;
        }
        else
        {
            *this = static_cast<A>(apa);
        }
        return *this;
    }

    int val;
};

使用示例：

int main() {
    A a(4), b(5), c(6);
    std::cout << a+b << std::endl; //Temporary created
    a = b+c;                       //Temporary created
    a = a+b;                       //No temporary - inplace operation
    std::cout << a << std::endl;
    return 0;
}

也可以优化a = b + c 以避免创建临时的，但我这里没有这样做。其他可能的优化是处理一系列操作以避免在每个步骤中创建临时操作。