c++ - prefija - Operadores de incremento de prefijo/postfijo

postfijo en c

Question

Quiero asegurarme de que entiendo el paso por valor frente al paso por referencia correctamente. En particular, estoy viendo las versiones de prefijo / postfijo del operador increment ++ para un objeto.

Supongamos que tenemos la siguiente clase X :

class X{
private:
    int i;
public:
 X(){i=0;}
 X& operator ++ (){ ++i; return *this; } //prefix increment

 X operator ++ (int unused){ //postfix increment
  X ret(*this);
  i++;
  return ret;
 }

 operator int(){ return i; } //int cast
};

En primer lugar, ¿he implementado los operadores de incremento de prefijo / postfijo correctamente?

Segundo, ¿qué tan eficiente es la memoria en el operador de postfix, en comparación con el operador de prefijo? Específicamente, ¿cuántas copias de objetos X se crean cuando se usa cada versión del operador?

Una explicación de qué es exactamente lo que sucede con la devolución por referencia frente a la devolución por valor podría ayudarme a comprender.

Edición: Por ejemplo, con el siguiente código ...

X a;
X b=a++;

... son a y b ahora alias?

Answer 1

Es más idiomático llamar al incremento de prefijo del propio objeto en el incremento de postfix:

X operator++(int)
{
    X copy(*this);
    ++*this;         // call the prefix increment
    return copy;
}

La lógica de incrementar un objeto X está contenida únicamente dentro de la versión del prefijo.

Answer 2

Esta es una implementación correcta. Es típico que un operador de postfix sea peor en el rendimiento porque tiene que crear otra copia antes de hacer el incremento (y es por eso que tengo la costumbre de usar siempre el prefijo a menos que necesite algo más).

Con la devolución por referencia, está devolviendo una referencia de valor l al objeto actual. El compilador normalmente implementaría esto devolviendo la dirección del objeto actual. Esto significa que devolver el objeto es tan simple como devolver un número.

Sin embargo, con la devolución por valor, se debe hacer una copia. Esto significa que hay más información para copiar durante la devolución (en lugar de solo una dirección), así como un constructor de copia para llamar. Aquí es donde entra su éxito de rendimiento.

La eficiencia de su implementación se ve a la par con las implementaciones típicas.

EDIT: Con respecto a su adición, no, no son alias. Has creado dos objetos separados. Cuando regresa por valor (y cuando creó un nuevo objeto desde el operador de incremento postfix), este nuevo objeto se coloca en una ubicación de memoria distinta.

Sin embargo, en el siguiente código, a y b son alias:

 int a = 0;
 int& b = ++a;

b es una dirección que hace referencia a.

Answer 3

Sus operadores están implementados correctamente.

En el operador de prefijo, no se hacen copias de X.

En el operador de postfix, se hace una copia para ret, y potencialmente se hace otra copia al regresar de la función, pero todos los compiladores eligen esta copia.