Question

Is it safe to write our own copy constructor always during operator overloading ?

Complex Complex::operator+(const Complex&  other)
{
    Complex local ;
    local.result_real = real + other.real;
    local.result_imaginary = imag + other.imag;
    return local ;
}

Most of the times i have seen the above format , instead of returning it as reference .

Can we take thumb rule like
1- Always pass the function parameter by reference .
2- Always return the object by reference .

Is there any special case in operator overloading where we have to return the object by value only ?

Answer 1

Can we take thumb rule like 1- Always pass the function parameter by reference . 2- Always return the object by reference .

No, not really. Even if you found a way to return a non-dangling reference, an operation such as addition should not return a reference, since this does not make sense. a+b should return a new object, while for a+=b it does make sense to return a reference to the LHS.

Concerning passing an argument by reference, there is no rule of thumb either. Consider this:

A operator+(const A& lhs, const A& rhs)
{
  A tmp = lhs; // explicitly make a copy
  return tmp += rhs;
}

and this:

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

The second version passes one argument by value, resulting in simpler code and giving the compiler more opportunities to elide temporary copies.