¿Cómo sobrecargar el operador++ de dos maneras diferentes para postfix a++ y prefix ++a?

La diferencia radica en qué firma eliges para tu(s) sobrecarga (es) de operator ++.

Citado del artículo relevante sobre este tema en las preguntas frecuentes de C++ (vaya allí para más detalles):

class Number {
  public:
    Number& operator++ ();     // prefix ++: no parameter, returns a reference
    Number  operator++ (int);  // postfix ++: dummy parameter, returns a value
};

P.d.: Cuando me enteré de esto, todo lo que vi inicialmente fue el parámetro dummy, pero los diferentes tipos de retorno son en realidad más interesantes; podrían explicar por qué ++x se considera más eficiente que x++ en general .

Tiene dos formas de sobrecargar los dos operadores (prefijo/postfijo) ++ para un tipo T:

Método del objeto:

Esta es la forma más fácil, usando el lenguaje "común" OOP.

class T
{
    public :
        T & operator++() // ++A
        {
            // Do increment of "this" value
            return *this ;
        }

        T operator++(int) // A++
        {
           T temp = *this ;
           // Do increment of "this" value
           return temp ;
        }
} ;

Objeto función no miembro:

Esta es otra forma de hacer esto: Siempre que las funciones estén en el mismo espacio de nombres que el objeto al que se refieren también, se considerarán cuando el compilador busque una función para manejar ++t ; o t++ ; código:

class T
{
    // etc.
} ;


T & operator++(T & p_oRight) // ++A
{
   // Do increment of p_oRight value
   return p_oRight ;
}

T operator++(T & p_oRight, int) // A++
{
   T oCopy ;
   // Copy p_oRight into oCopy
   // Do increment of p_oRight value
   return oCopy ;
}

Es importante recuerde que, desde un punto de vista de C++ (incluyendo un punto de vista de compilador de C++), esas funciones no miembro siguen siendo parte de la interfaz de T (siempre y cuando estén en el mismo espacio de nombres).

Hay dos ventajas potenciales de la notación de función no miembro:

• Si logras codificarlos sin hacerlos amigos de T, entonces aumentas la encapsulación de T
• puede aplicar esto incluso a clases o estructuras cuyo código no posee. Esta es una forma no intrusiva para mejorar la interfaz de un objeto sin modificar su declaración.

Sé que es tarde, pero tuve el mismo problema y encontré una solución más simple. No me malinterpretes, esta es la misma solución que la primera (publicada por Martin York). Es solo un bit más simple. Sólo un poco. Aquí está:

class Number
{
        public:

              /*prefix*/  
        Number& operator++ ()
        {
            /*Do stuff */
            return *this;
        }

            /*postfix*/
        Number& operator++ (int) 
        {
            ++(*this); //using the prefix operator from before
            return *this;
        }
};

La solución anterior es un poco más simple porque no utiliza un objeto temporal en el método postfix.

Declara así:

class A
{
public:
    A& operator++();    //Prefix (++a)
    A operator++(int); //Postfix (a++)

};

Implementar correctamente - no meterse con lo que todos saben que hacen (incrementar luego usar, usar luego incrementar).