Question

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

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

x = x op y

会认识到它是自我分配的，而不是直接生成临时变量op = to 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以避免创建一个临时的，但我在这里没有做到。其他可能的优化是处理一系列操作，以避免在每一步创建临时。

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

1 个答案: