sobrecarga de incremento previo y post incremento

Question

vi un ejemplo acerca de cómo implementar pre-incremento y post-incremento, que afirma que la sobrecarga de incremento previo es capaz de ser definida como

T& T ::operator++() 

y la sobrecarga de incremento posterior puede ser definida e implementada en términos de pre-incremet de la siguiente manera

const T T::operator++(int){ 
    const T old(*this); 
    ++(*this); 
    return old; 
} 

tengo dos preguntas:

1) ¿qué significa “viejo”?

2) Se asume que ++ (* this) usa el preincremento, y la definición de preincremento original no tiene argumento. Sin embargo, tiene * esto aquí.

Answer 1

¿Qué significa "antiguo"?

El método es un incremento posterior. Se devuelve el valor actual ("valor anterior") y luego se incrementa el valor ("nuevo valor").

++ (* this) se supone que utiliza el preincremento, y la definición de preincremento original no tiene argumento. Sin embargo, tiene * esto aquí.

*this no es un argumento. Los paréntesis no son necesarios, están ahí para facilitar la lectura.
Es equivalente a ++*this.

Answer 2

old es simplemente un nombre de variable (no es una palabra clave, si eso es lo que te estabas preguntando). Se usa para guardar el valor anterior del operando.

Answer 3

1) "anterior" es el valor que tenía "this" antes de que se incrementara. Se supone que el incremento posterior devuelve ese valor.

2) ++ (* esto) es equivalente a this-> operador ++()

Answer 4

2) ++ (* este) se supone que utilizar el pre-incremento, y el original pre- la definición de incremento no tiene argumento. Sin embargo, tiene * este aquí.

++ es un operador unario, por lo que tiene un argumento bien. Siempre que sobrecarga un operador como función miembro, el primer argumento es el objeto actual.

El parámetro int no utilizado es solo un truco para distinguir entre incremento previo y posterior, porque operator++ puede significar cualquiera de los dos. El post-incremento realmente no acepta un entero *, es solo una construcción de lenguaje (incómoda).

También puede sobrecargar estos operadores como funciones gratuitas:

struct T 
{ 
    int n; 
}; 

T& operator++(T& t) { ++t.n; return t; } 
T operator++(T& t, int) { T old(t); ++t; return old; } 

int main() 
{ 
    T a; 
    T b = a++; 
    ++b; 
} 

* con un uso normal. Cuando invoca al operador utilizando la sintaxis de llamada de función, puede pasar un int adicional para distinguir entre esos dos:

operator++(a); //calls-preincrement 
operator++(b, 1); //calls post-increment