how to apply operator overloading for unary postfix operator

Question

below is code for operator overloading for unary operator ++

#include <iostream>
using namespace std;
 
class Distance {
   private:
      int feet;             // 0 to infinite
      int inches;           // 0 to 12
      
   public:
      // required constructors
      Distance() {
         feet = 0;
         inches = 0;
      }
      Distance(int f, int i) {
         feet = f;
         inches = i;
      }
      
      // method to display distance
      void displayDistance() {
         cout << "F: " << feet << " I:" << inches <<endl;
      }
      
      // overloaded minus (-) operator
      Distance operator++ () {
         feet = feet+1;
         inches = inches+1;
         
         return Distance(feet, inches);
      }
};

int main() {
   Distance D1(11, 10), D2(-5, 11);
 
   ++D1;                     // increment by 1
   
   D1.displayDistance();    // display D1

   ++D2;                     // increment by 1
   D2.displayDistance();    // display D2

   return 0;
}

when I use above code then I can successfully use prefix operator ++D1 and ++D2 but I am not getting how to overload postfix operator D1++ and D2++ even if I try these in above code it showing me error so how can we use concept of operator overloading for postfix and prefix separately?

Answer 1

For postfix operator++ you have to specify an extra(unused) parameter of type int as shown below:

class Distance {
   
      //other code as before
      public:
      Distance operator++(int);//declaration for postfix operator++
};

//other code as before 

//definition for postfix operator++
Distance Distance::operator++(int)
{    
    Distance ret = *this;   // save the current value
    
    ++*this;     // use prefix ++
    return ret;  // return the saved state
}

See DEMO.

Explanation

There is a problem when defining both the prefix and postfix operators because both of these versions use the same symbols, meaning that the overloaded versions of these operators have the same name. Moreover, they also have the same number and type of operands.

So to solve this problem, the postfix version take an extra parameter of type int. And when we use the postfix operator, the compiler automatically/implicitly supplies 0 as the argument for this parameter.