C++ 重载类外的运算符

因此，我有一个简单的类：

class complex{

private:

    double a,b;

public:

    void setA(double a){ this->a=a; }

    void setB(double b){ this->b=b; }

    double getA(){ return a; }
    double getB(){ return b; }

    friend complex operator+(const complex&, const complex&);
};

这里有一个实际的重载运算符：

complex operator+(const complex& x, const complex& y){

    complex c;
    c.a=x.a+y.a;
    c.b=x.b+y.b;
    return c;
}

我必须在函数外重载运算符。为了能够访问私有变量（那些也必须是私有的），我让类与函数成为朋友。我不知道这样做是否正确，但至少是可行的。 我希望能够向两个成员添加一个整数。在main（）中：

将导致a.a=7和a.b=8。类内的这种重载很容易产生（同样，不知道这是否是一个好的解决方案，如果不是，请纠正我）：

---

但是我不知道如何使它在类之外，因为我不能使用“this”指针。

解决这类问题的通常方法是让定义算术运算符的自反版本的成员函数和定义非自反版本的自由函数用自反版本实现。不需要朋友声明。例如：

class complex {
public:
    complex& operator+=(const complex& rhs) {
        x += rhs.x;
        y += rhs.y;
        return *this;
    }
private:
    double x, y;
};

complex operator+(const complex& lhs, const complex& rhs) {
    complex result = lhs;
    result += rhs;
    return result;
}

---

让

a+5

更改

a

的值是不寻常的，但如果这确实是您想要的，请将

operator+（int）

设为成员。然而，用户通常会期望

a+5

保持

a

不变，

a+=5

会修改

a

解决这类问题的通常方法是使用定义算术运算符自反版本的成员函数和定义非自反版本的自由函数，使用自反版本实现。不需要朋友声明。例如：

class complex {
public:
    complex& operator+=(const complex& rhs) {
        x += rhs.x;
        y += rhs.y;
        return *this;
    }
private:
    double x, y;
};

complex operator+(const complex& lhs, const complex& rhs) {
    complex result = lhs;
    result += rhs;
    return result;
}

---

让

a+5

更改

a

的值是不寻常的，但如果这确实是您想要的，请将

operator+（int）

设为成员。然而，用户通常希望

a+5

保持

a

不变，而

a+=5

会修改

a

@ard\u evon-这是一个拼写检查-o。固定的。谢谢。@ard_evon-这是拼写检查。固定的。谢谢。在类内部实现的运算符必须省略左侧操作数参数，而使用

this

。在类之外实现的运算符必须具有左侧操作数参数，并且不能使用

this

。但是，您的类成员

运算符+（）

实现错误，您不应该修改

this

的值，运算符将返回一个新对象，以便进行修改。在类内部实现的运算符必须省略左侧操作数参数，而使用

this

。在类之外实现的运算符必须具有左侧操作数参数，并且不能使用

this

。但是，您的类成员

操作符+（）

实现错误，您不应该修改

this

的值，操作符返回一个新对象，因此改为修改它。

class complex {
public:
    complex& operator+=(const complex& rhs) {
        x += rhs.x;
        y += rhs.y;
        return *this;
    }
private:
    double x, y;
};

complex operator+(const complex& lhs, const complex& rhs) {
    complex result = lhs;
    result += rhs;
    return result;
}