Ad

Wednesday, August 15, 2007

Overloading Increment/Decrement Operators

In this article we are going to overload the increment (++) and decrement (--) operators by using operator overloading.

As increment (++) and decrement (--) are unary operators, therefore the operator functions that we need to define won’t take any arguments.

These operators are overloaded as usual so further discussion is not required and we straightaway look at the example program:


  // overloading the increment 
  // and decrement operators
  #include <iostream.h>

  // class
  class myclass
  {
    int a;

  public:
    myclass(int);
    void show();

    void operator ++();
    void operator --();
  };

  myclass::myclass(int x)
  {
    a=x;
  };

  void myclass::show()
  {
    cout<<a<<endl;
  }

  void myclass::operator ++()
  {
    // increment a
    a++;
  }

  void myclass::operator --()
  {
    // decrement a
    a--;
  }

  // main
  void main()
  {
    myclass ob(10);

    ob.show();

    ++ob;
    ob.show();

    --ob;
    ob.show();
  }

The overloaded (++ and --) operators in the above program has some problems however. As operator functions are not returning anything therefore a statement like the one below is not legal.

  ob2 = ++ob;

Although pretty much used the above statement is not possible, of course unless we return the object that generated the call from the overloaded operator function. As in the line:

  ob2 = ++ob;

If we return the object ‘ob’ from the overloaded operator function then the above statement would be perfectly legal.

To do this the ‘this’ pointer is used. The program with slight modification is below:


  // overloading the increment 
  // and decrement operators
  //  -- corrected version --
  #include <iostream.h>

  // class
  class myclass
  {
    int a;

  public:
    myclass(int);
    void show();

    myclass operator ++();
    myclass operator --();
  };

  myclass::myclass(int x)
  {
    a=x;
  };

  void myclass::show()
  {
    cout<<a<<endl;
  }

  myclass myclass::operator ++()
  {
    // increment a
    a++;

    // return the object
    // that generated call
    return *this;
  }

  myclass myclass::operator --()
  {
    // decrement a
    a--;

    // return the object
    // that generated call
    return *this;
  }

  // main
  void main()
  {
    myclass ob(10);
    myclass ob2(100);

    ob.show();

    ++ob;
    ob.show();

    // now this is legal
    // as the incremented
    // value of ob may be
    // assigned to other
    // objects
    ob2=++ob;
    ob2.show();

    --ob2;
    ob2.show();
  }

This is one of the situations when you can’t live without using the ‘this’ pointer!

NOTE: This way we can overload prefix form of the increment and decrement operators, we'll be discussing postfix form in the coming articles.

Related Articles:

5 comments:

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.