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