Operator Overloading using Friend Functions with Complex Numbers

Operator overloading using friend functions:


Operators can be overloaded in c++ with friend functions also. The procedure is same as we discussed earlier. Here I will demonstrate operator overloading with "+" operator which is a binary operator. I will be using a complex number class (called complex). The class will have 2 data types, real and imaginary.
Operator overloading will not be a part of class complex, but we will declare that this function is a friend of class complex.

Note that since overloaded function is not part of class , so will require 2 args (overloading with member function require 1 arg for binary operator, as the first arg is the object itself.)
Use:
Most student wonder why we need to use operator overloading in such manner? The answer is simple, this will allow you to manipulate operator for predefined objects that you mat not have access. (Like cout or cin)

Code:

#include<iostream>


using namespace std;
// complex class with real and imaginary part
class complex
{
    public:
    int real;
    int img;
    //default constructor
    complex()
    {
        real=img=0;    
    }
    //overloaded constructor with 2 args
    complex(int x,int y)
    {
        real=x;
        img=y;    
    }
    //show function to display complex number
    void show()
    {
        cout<<"\n"<<real<<"+"<<img<<"i";
    }
    //declaring that "opeartor+" is friend of class complex
    friend complex operator+(complex c,complex d);
};

//operator+ is not part of complex class so have 2 args for + operator overload.
complex operator+(complex c, complex f)
{
    complex ans;
    ans.real=c.real+f.real;
    ans.img=c.img+f.img;
    return(ans);
}
int main()
{
    complex x(1,2), y(0,7);
    complex c=x+y;//overloaded + is called here
    //note that compiler will convert this to
    // c=operator+(x,y)
    c.show();
}