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

Question

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

我的目标是一些任意 class 和重载运算符

x = x op y

会认识到它是自赋值的，而不是直接将 op= 生成一个临时变量给 x（我不只是想重载 op=）。有办法吗？

Answer 1

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

诀窍在于，在 class A 中，您实现了一个采用 APlusA 临时对象的 operator= 版本。如果它识别出它正在对同一对象进行操作，则它可以就地执行操作，而无需创建临时 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 以避免创建临时文件，但我在这里没有这样做。其他可能的优化是处理一系列操作以避免在每个步骤创建临时文件。

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

Detect self-assignment in overloaded C++ operators

c++

class

operator-overloading