sobrecarga de operadores de sufijo y el prefijo

Question

favor considere siguiente código

#include <iostream> 
using namespace std; 
class Digit 
{ 

private: 
    int m_digit; 
public: 
    Digit(int ndigit=0){ 
    m_digit=ndigit; 
         } 
    Digit& operator++();//prefix 
    Digit& operator--(); //prefix 
     Digit operator++(int); 
     Digit operator--(int); 
     int get() const { return m_digit;} 
}; 
Digit& Digit::operator++(){ 

    ++m_digit; 
    return *this; 
} 
Digit& Digit::operator--(){ 
--m_digit; 
return *this; 

} 
Digit Digit::operator++(int){ 
Digit cresult(m_digit); 
++(*this); 
return cresult; 


} 
    Digit Digit::operator--(int){ 
Digit cresult(m_digit); 
--(*this); 
return cresult; 


} 
    int main(){ 

    Digit cDigit(5); 
     ++cDigit; 
     cDigit++; 
     cout<<cDigit.get()<<endl; 
     cout<<cDigit.get()<<endl; 





    return 0; 
    } 

aquí se implementa dos versiones de operadores de sufijo y el prefijo, he leído esa diferencia se hace por introducir otro llamado argumento ficticio, pero tengo pregunta si vemos declaración de estos

Digit& operator++();//prefix 
      Digit& operator--(); //prefix 
     Digit operator++(int); 
     Digit operator--(int); 

que se diferenciaban por & marca, así que por qué es necesaria argumento ficticio? y también en ambos casos, por ejemplo, el operador ++ está escrito antes de la vista y no significa que sean ¿mismo?

Answer 1

El incremento previo y posterior son dos operadores distintos y requieren sobrecargas por separado.

C++ no permite la sobrecarga únicamente en el tipo de devolución, por lo que tener diferentes tipos de devolución como en su ejemplo no sería suficiente para eliminar la ambigüedad de los dos métodos.

El argumento ficticio es el mecanismo que el diseñador de C++ eligió para la desambiguación.

Answer 2

El operador, al igual que cualquier función, se identifica con la firma. El tipo de devolución y los modificadores anteriores al nombre de la función/operador no están incluidos en esto. Sus nombres operadores están aquí

operator++() 
operator++(int) 

Ésta es la única forma en que el compilador distingue entre los dos. En cuanto a los valores de retorno Digit& y Digit; Se necesitan debido a la forma en que se supone que ++ x, y x ++ operan.

Answer 3

En C++ las funciones/métodos no se pueden sobrecargar por tipo de retorno, solo por lista de parámetros. Ignorando el hecho de que los operadores de prefijo y postfijo son operadores, imagínese si fueran simplemente otras funciones, ¿cómo resolvería el compilador cuál usar según el tipo de retorno? P.ej.

int x = 2; 

const int DoIt() 
{ 
    return 1; 
} 

int& DoIt() 
{ 
    return x; 
} 

int y = DoIt(); 

Desde sobrecargas de operadores en realidad sólo son funciones en el corazón, no hay manera para que el compilador para diferenciar entre ellos según el tipo de retorno.

Ver http://www.parashift.com/c++-faq-lite/operator-overloading.html#faq-13.14

Answer 4

En Pre-incremento/decremento y post incremento/decremento, la diferencia se basa en único parámetro maniquí en función sobrecargada

operator++()   => Prefix Increment 
operator--()   => Prefix Decrement 

operator++(int)  => Postfix Increment 
operator--(int)  => Postfix Decrement 

tipo de retorno puede ser el mismo. También puede consultar: http://www.tutorialspoint.com/cplusplus/increment_decrement_operators_overloading.htm