c++ - peru - prefijo canada toronto

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

Question

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

Answer 1

Debería verse así:

class Number 
{
    public:
        Number& operator++ ()     // prefix ++
        {
           // Do work on this.   (increment your object here)
           return *this;
        }

        // You want to make the ++ operator work like the standard operators
        // The simple way to do this is to implement postfix in terms of prefix.
        //
        Number  operator++ (int)  // postfix ++
        {
           Number result(*this);   // make a copy for result
           ++(*this);              // Now use the prefix version to do the work
           return result;          // return the copy (the old) value.
        }
}; 

Answer 2

Declara así:

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

};

Implemente correctamente - no se meta con lo que todos saben que hacen (incremente luego use, use luego incremente).

Answer 3

La diferencia radica en qué firma elige para su (s) sobrecarga (s) del 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
};

PD: Cuando me enteré de esto, todo lo que vi inicialmente fue el parámetro ficticio, 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 .

Answer 4

Sé que es tarde, pero tuve el mismo problema y encontré una solución más simple. No me malinterpreten, esta es la misma solución que la superior (publicada por Martin York). Es solo un poco más simple. Solo 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 usa un objeto temporal en el método postfix.

Answer 5

Tienes 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, utilizando expresiones idiomáticas OOP "comunes".

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 ;
        }
} ;

Función no miembro de objeto:

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 están refiriendo también, se tendrán en cuenta cuando el compilador buscará 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 recordar que, desde un punto de vista de C ++ (incluido un punto de vista del compilador de C ++), esas funciones que no son miembros siguen siendo parte de la interfaz de T (siempre que 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 aumentaste la encapsulación de T
• Puede aplicar esto incluso a clases o estructuras cuyo código no sea de su propiedad. Esta es una forma no intrusiva de mejorar la interfaz de un objeto sin modificar su declaración.