Question

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

Obj1 + Obj2
12 + Obj2
Obj1 + 10

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

Obj1-Obj2
12-Obj2
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);。

因此我要说的是，内部运算符重载的工作方式与使用dot（。）运算符调用函数一样。因此Obj1.addInt(5)将返回Complex类型的对象，并将在Obj2中进行分配。同样，Obj1 + 5也将返回复杂类型的对象。

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

但是好友功能的内部工作方式不同。现在，每当我们定义一个朋友函数时，对于相同的操作，它都会使用两个参数。这意味着该朋友函数不使用dot（。）运算符来调用任何东西，而是使用两个参数并返回一个Complex类型的对象。

注意：-如果两个参数都是Complex类型，则可以正常工作，因为Complex Obj3 = Obj1 + Obj2;将扩展为Complex Obj3 = Obj1.AddComplex(Obj2);，而Complex Obj3 = Obj2 + Obj1;将扩展为Complex Obj3 = Obj2.AddComplex(Obj1);。两种情况的第一个参数都是“复杂”。

重载+和-运算符时出现错误

1 个答案: