por favor, considere el 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 la versión dos de postfix y operadores de prefijo,he leído que la diferencia es hecha por introducir otro llamado dummy argumento,pero tengo duda si vemos la declaración de estos

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

que se diferenciaron por & marca,así que ¿por qué es necesario ficticio argumento?y también en ambos caso, por ejemplo, ++ operador se escribe antes del argumento y no significa que no son lo mismo?

OriginalEl autor dato datuashvili | 2011-10-12

4 Comentarios

  1. 10

    El pre – y post-incremento de dos operadores, y requieren separado sobrecargas.

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

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

    Me imagino que hay una nota en el brazo o en algún lugar de por qué este fue el método elegido para la desambiguación. La respuesta es, probablemente, tan simple como «no hay otro camino.»

    OriginalEl autor NPE

  2. 2

    El operador, así como cualquier función, es identificado por la firma. El tipo de retorno y modificadores antes de la función/nombre del operador no está incluido en este. Sus operadores nombres están aquí

    operator++()
    operator++(int)

    Esta es la única forma en que el compilador distingue entre los dos. Como para el Digit& y Digit valores de retorno; son necesarios debido a la forma ++x, y x++ se supone que para operar.

    OriginalEl autor Captain Giraffe

  3. 2

    En C++ las funciones/métodos no puede ser sobrecargado por el tipo de retorno, solamente por la lista de parámetros. Ignorando el hecho de que el prefijo de postfix y los operadores son operadores, imagino que si eran simples otras funciones, cómo sería el compilador de trabajo que se utiliza, según el tipo de retorno? E. g.

    int x = 2;
    
    const int DoIt()
    {
        return 1;
    }
    
    int& DoIt()
    {
        return x;
    }
    
    int y = DoIt();

    Desde las sobrecargas de operador son realmente funciones en el corazón, no hay manera para que el compilador se diferencian entre ellos por el tipo de retorno.

    Ver http://www.parashift.com/c++-faq-lite/operador de la sobrecarga.html#faq-13.14

    OriginalEl autor blaaaaaaah

Dejar respuesta

Please enter your comment!
Please enter your name here