Getting error while overlloading + and - operator

Question

Overload Operator + to implement below operations:

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

Overload Operator - to implement below operations:

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

Mainly looking to overload: Obj1 - 10, 12 - Obj2, 12 + Obj2, Obj1 + 10 cases I wanted to overload operator + and - such that above all operation are handled. How to handle these operation/cases? Here I am facing problem with 2nd case. I am thinking to write only one function each for + and - to handle these case.

#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();
}

Expected Output:

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

Getting below error:

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

Answer 1

It should not be like this Complex Obj4 = 10 + Obj3; Instead it should be like this Complex Obj4 = Obj3 + 10;

As per you have defined function to overload operator the first argument should be of complex type not int type.

Do it like this:-

#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();
}

If you want to write one function for each(+ and -) then consider using templates.

As I have already told you the first argument should be of complex type, but I think I should explain you why?

Below are two programs try to understand them carefully.

First Program:

#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;
}

Second Program:

#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;
}

Consider statement Obj2=Obj1 + 5; and Obj2=Obj1.addInt(5); in first program and second program respectively.

So from this I want to say that internally operator overloading works just like calling a function using dot(.) operator.So Obj1.addInt(5) will return an object of type Complex and will be assigned in Obj2. Similarly Obj1 + 5 will also return an object of type Complex.

So if you will not provide first argument of Complex type, like you was doing like this Complex Obj4 = 10 + Obj3; which will expand something like Obj4= 10.AddInt(Obj4);. Now 10 is not any object so how we can call a method(member function) using a dot operator.

But the internal working of friend function is different. Now whenever we are defining a friend function, for the same operation, it is taking two arguments. It means that friend function is not calling anything using dot(.) operator, instead it takes two arguments and return a object of type Complex.

Note:- If both arguments are of Complex type then it works fine because Complex Obj3 = Obj1 + Obj2; will expand to Complex Obj3 = Obj1.AddComplex(Obj2); and Complex Obj3 = Obj2 + Obj1; will expand to Complex Obj3 = Obj2.AddComplex(Obj1);.So in both cases first argument is Complex.