重载 + 和 - 运算符时出错

Question

重载运算符+实现以下操作：

1. Obj1 + Obj2
2. 12 + Obj2
3. Obj1 + 10

重载运算符 - 实现以下操作：

1. Obj1 - Obj2
2. 12 - Obj2
3. Obj1 - 10

主要看重载：Obj1-10、12-Obj2、12+Obj2、Obj1+10例 我想重载运算符 + 和 - 以便处理所有操作。如何处理这些操作/案例？ 在这里，我面临第二种情况的问题。我正在考虑只为 + 和 - 编写一个函数来处理这些情况。

#include<iostream>
using namespace std;

class Complex {
private:
    int real, imag;
public:
    Complex(int r = 0, int i =0)  {real = r;   imag = i;}

     Complex operator + (Complex const &obj) {
     Complex res;
     res.real = this->real + obj.real;
     res.imag = this->imag + obj.imag;
     return res;
}

     Complex operator + (int i) {
     Complex res;
     res.real = this->real + i;
     res.imag = this->imag ;
     return res;
}
    Complex operator - (Complex const &obj) {
      Complex res;
     res.real = this->real - obj.real;
     res.imag = this->imag - obj.imag;
     return res;
    }
  Complex operator - (int i) {
      Complex res;
     res.real = this->real - i;
     res.imag = this->imag ;
     return res;
    }
    void print() { cout << real << " + i" << imag << endl; }
};  

int main()
{
    Complex Obj1(10, 5), Obj2(2, 4);
    Complex Obj3 = Obj1 + Obj2; 
    Complex Obj4 = 10 + Obj3; 
    Complex Obj5 = Obj4 + 15;
    cout<<" + operation:"<<endl;
    Obj3.print();
    Obj4.print();
    Obj5.print();
    Complex Obj6 = Obj1 - Obj2; 
    Complex Obj7 = 10 - Obj3; 
    Complex Obj8 = Obj4 - 15;
    cout<<" - operation:"<<endl;
    Obj6.print();
    Obj7.print();
    Obj8.print();
}

预期输出：

 + operation:    
 12 + i9     
 22 + i9     
 37 + i9   
 - operation:   
 8 + i    
 2 + i9     
 7 + i9    

出现以下错误：

error: no match for 'operator+' (operand types are 'int' and 'Complex')
         Complex Obj4 = 10 + Obj3; 

Answer 1

不应该是这样的Complex Obj4 = 10 + Obj3; 而应该是这样的Complex Obj4 = Obj3 + 10;

根据您定义的函数来重载运算符，第一个参数应该是复杂类型而不是 int 类型。

这样做：-

#include<iostream>
using namespace std;

class Complex {
private:
    int real, imag;
public:
    Complex(int r = 0, int i =0)  {real = r;   imag = i;}

     Complex operator + (Complex const &obj) {
     Complex res;
     res.real = this->real + obj.real;
     res.imag = this->imag + obj.imag;
     return res;
}

     friend Complex operator + (int i, Complex const &obj) {
     Complex res;
     res.real = obj.real + i;
     res.imag = obj.imag ;
     return res;
}
    Complex operator - (Complex const &obj) {
      Complex res;
     res.real = this->real - obj.real;
     res.imag = this->imag - obj.imag;
     return res;
    }
  friend Complex operator - (int i, Complex const &obj) {
      Complex res;
     res.real = obj.real - i;
     res.imag = obj.imag ;
     return res;
    }
    void print() { cout << real << " + i" << imag << endl; }
};  

int main()
{
    Complex Obj1(10, 5), Obj2(2, 4);
    Complex Obj3 = Obj1 + Obj2; 
    Complex Obj4 = 10 + Obj3; 
    Complex Obj5 = Obj4 + 15;
    cout<<" + operation:"<<endl;
    Obj3.print();
    Obj4.print();
    Obj5.print();
    Complex Obj6 = Obj1 - Obj2; 
    Complex Obj7 = 10 - Obj3; 
    Complex Obj8 = Obj4 - 15;
    cout<<" - operation:"<<endl;
    Obj6.print();
    Obj7.print();
    Obj8.print();
}

如果您想为每个（+ 和 -）编写一个函数，请考虑使用模板。

正如我已经告诉你的，第一个参数应该是复杂类型的，但我想我应该解释一下为什么？

下面是两个尝试仔细理解的程序。

第一个程序：

#include<iostream>
using namespace std;

class Complex {
private:
    int real, imag;
public:
    Complex(int r = 0, int i =0)  {real = r;   imag = i;}

     Complex operator +(int i) {
        Complex res;
        res.real = this->real + i;
        res.imag = this->imag;
        return res;
    }
    void printComplex(){
        cout<<"Real="<<this->real<<" Imaginary="<<this->imag;
    }
};  

int main()
{
    Complex Obj1(10, 5);
    Complex Obj2;
    Obj2=Obj1 + 5;
    Obj2.printComplex();
    return 0;
}

第二个节目：

#include<iostream>
using namespace std;

class Complex {
private:
    int real, imag;
public:
    Complex(int r = 0, int i =0)  {real = r;   imag = i;}

     Complex addInt(int i) {
        Complex res;
        res.real = this->real + i;
        res.imag = this->imag;
        return res;
    }
    void printComplex(){
        cout<<"Real="<<this->real<<" Imaginary="<<this->imag;
    }
};  

int main()
{
    Complex Obj1(10, 5);
    Complex Obj2;
    Obj2=Obj1.addInt(5);
    Obj2.printComplex();
    return 0;
}

分别在第一个程序和第二个程序中考虑语句Obj2=Obj1 + 5; 和Obj2=Obj1.addInt(5);。

因此我想说，内部运算符重载就像使用点（。）运算符调用函数一样。所以Obj1.addInt(5) 将返回一个复杂类型的对象，并将在Obj2 中分配。同样，Obj1 + 5 也会返回一个 Complex 类型的对象。

因此，如果您不提供复杂类型的第一个参数，就像您所做的 Complex Obj4 = 10 + Obj3; 那样，它将扩展类似 Obj4= 10.AddInt(Obj4); 的内容。现在10 不是任何对象，所以我们如何使用点运算符调用方法（成员函数）。

但是友元函数的内部工作是不同的。现在，每当我们定义一个友元函数时，对于同一个操作，它都需要两个参数。 这意味着友元函数不使用点（。）运算符调用任何东西，而是接受两个参数并返回一个复杂类型的对象。

注意：- 如果两个参数都是 Complex 类型，那么它可以正常工作，因为 Complex Obj3 = Obj1 + Obj2; 将扩展为 Complex Obj3 = Obj1.AddComplex(Obj2); 和 Complex Obj3 = Obj2 + Obj1; 将扩展为 Complex Obj3 = Obj2.AddComplex(Obj1);。所以在这两种情况下，第一个参数都是 Complex。