Overloading Increment/Decrement Operators using Friend Functions

In the article Operator
Overloading using Friend Functions, we saw how we can overload simple
operators using friend functions, in the other article Overloading
Increment/Decrement Operators, we saw the method of overloading increment/decrement
operators as member functions. Combining both these, we’ll try to overload
the increment/decrement operators using friend
functions, in this article.

As we know there are some differences in overloading operators as a friend.

Increment/decrement are the type of operators that need to change the operands
itself. In the case of operator overloading as member functions, ‘this’
pointer was passed so any change done would result in the operand itself
getting changed. But in the case of friend functions, operands are passed explicitly
and that also as call by value, hence it is impossible to change the operand
that way.

Let’s take an example, suppose we have an object ‘ob’of a
class say 'myclass' which overloads the increment operator,

  ob++;

This statement would result in a call to the overloaded increment (++) operator
function, which could be something like the one below:

  myclass operator++()
  {

    a++;
    b++;

    return *this;
  }

Supposing the data of the class we need to alter are a and b, the above statement
would increment the data of the object that generated the call, hence the desired
result is achieved.

Had the function been overloaded as a friend something like this:

  myclass operator++(myclass ob)
  {
    ob.a++;
    ob.b++;

    return ob;
  }

Then the operand’s copy (not the actual object that generated the call)
would have been passed to the function and any change (a++ and b++) would only
have incremented the data of the copy of the object passed (call by value) and
the data of the operand would have remained unchanged.

To overcome this we need to accept the reference
of the object (call by reference) as the argument to overload the operators
as a friend.

The following program illustrates this method:


  // Program to illustrate the overloading
  // of increment / decrement operators
  // as friends
  // NOTE: Prefix form is overloaded here
  #include <iostream.h>

  class myclass
  {
    int a;
    int b;

  public:
    myclass(){}
    myclass(int x,int y){a=x;b=y;}
    void show()
    {
      cout<<a<<endl<<b<<endl;
    }

    // accepting references
    friend myclass operator++(myclass&);
    friend myclass operator--(myclass&);

  };

  myclass operator++(myclass &ob)
  {
    ob.a++;
    ob.b++;

    return ob;
  }

  myclass operator--(myclass &ob)
  {
    ob.a--;
    ob.b--;

    return ob;
  }

  void main()
  {
    myclass a(10,20);
    myclass b(100,200);

    ++a;
    ++b;

    a.show();
    b.show();

    a=--b;

    a.show();
    b.show();
  }