Why ++ operator overloading expect (int) ?

[nitin1]

#include <iostream>
using namespace std;

class Time
{
   private:
      int hours;             // 0 to 23
      int minutes;           // 0 to 59
   public:
      // required constructors
      Time(){
         hours = 0;
         minutes = 0;
      }
      Time(int h, int m){
         hours = h;
         minutes = m;
      }
      // method to display time
      void displayTime()
      {
         cout << "H: " << hours << " M:" << minutes <<endl;
      }
      // overloaded prefix ++ operator
      Time operator++ ()  
      {
         ++minutes;          // increment this object
         if(minutes >= 60)  
         {
            ++hours;
            minutes -= 60;
         }
         return Time(hours, minutes);
      }
      // overloaded postfix ++ operator
      Time operator++( int)         
      {
         // save the orignal value
         Time T(hours, minutes);
         // increment this object
         ++minutes;                    
         if(minutes >= 60)
         {
            ++hours;
            minutes -= 60;
         }
         // return old original value
         return T; 
      }
};
int main()
{
   Time T1(11, 59), T2(10,40);

   ++T1;                    // increment T1
   T1.displayTime();        // display T1
   ++T1;                    // increment T1 again
   T1.displayTime();        // display T1

   T2++;                    // increment T2
   T2.displayTime();        // display T2
   T2++;                    // increment T2 again
   T2.displayTime();        // display T2

   system("pause");
   return 0;
}

Why does it need int in postfix and not in prefix? .I don't know why? I know when I do :

int a =1;
a++;

Then, it wants a as the parameter to increment it. But why is it taking in one case and not in other case? How compiler is passing the T1 argument to that overloaded function to increment the T1? Please explain. Thanks.

[deceptikon]

Why does it need int in postfix and not in prefix?

This is a case of Bjarne Stroustup being too clever. The two member functions need a different signature to resolve ambiguity between them. C++ doesn't differentiate between return types when comparing signatures, so it has to be done with either a function name or parameters. In the case of operator overloading, you can't change the name, so the only option without adding a new language feature is to require a dummy parameter. That's what the int parameter for postfix ++ does.

[nitin1]

but how is it resolved by compiler that which function to call? Who resolves this thing from the code compilation to source execution cycle? Thanks.

[deceptikon]

but how is it resolved by compiler that which function to call?

Compiler magic. ++T1 gets converted to T1.operator++() and T2++ gets converted to something like T2.operator++(0) under the hood. There's no ambiguity to resolve, the compiler recognizes which operator you used and calls the correct overload.

[rubberman]

nitin1: extremely awesome ;) You always explain awesomly. how? ;)

I think deceptikon had the "awesome C++ wizard" gene spliced into his DNA... :-)