Ad

Thursday, August 23, 2007

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

Related Articles:

2 comments:

  1. pls tell me how will this operator overloading work if we need it for post fix operation ..do give an example to explain.

    ReplyDelete

You are free to comment anything, although you can comment as 'Anonymous' it is strongly recommended that you supply your name. Thank You.

Please don't use abusive language.