C Language
Efectos secundarios

Operadores Pre / Post Incremento / Decremento

En C, hay dos operadores únicos: '++' y '-' que son una fuente muy común de confusión. El operador ++ se llama el operador de incremento y el operador -- se llama el operador de disminución . Ambos pueden usarse en forma de prefijo o de postfijo . La sintaxis para el formulario de prefijo para el operador ++ es ++operand y la sintaxis para el formulario postfix es operand++ . Cuando se usa en la forma de prefijo, el operando se incrementa primero en 1 y el valor resultante del operando se usa en la evaluación de la expresión. Considere el siguiente ejemplo:

int n, x = 5;
n = ++x; /* x is incremented  by 1(x=6), and result is assigned to n(6) */
         /* this is a short form for two statements: */
         /* x = x + 1; */ 
         /* n = x ; */

Cuando se usa en la forma de posfijo, el valor actual del operando se usa en la expresión y luego el valor del operando se incrementa en 1 . Considere el siguiente ejemplo:

int n, x = 5;
n = x++; /* value of x(5) is assigned first to n(5), and then x is incremented by 1; x(6) */
         /* this is a short form for two statements: */
         /* n = x; */
         /* x = x + 1; */

El funcionamiento del operador decremento -- puede entenderse de manera similar.

El siguiente código demuestra lo que hace cada uno.

    int main()
    {
        int a, b, x = 42;
        a = ++x; /* a and x are 43 */
        b = x++; /* b is 43, x is 44 */
        a = x--; /* a is is 44, x is 43 */
        b = --x; /* b and x are 42 */
        
        return 0;
    }

De lo anterior queda claro que los operadores de correos devuelven el valor actual de una variable y luego lo modifican, pero los operadores previos modifican la variable y luego devuelven el valor modificado.

En todas las versiones de C, el orden de evaluación de los operadores pre y post no está definido, por lo que el siguiente código puede devolver resultados inesperados:

    int main()
    {
        int a, x = 42;
        a = x++ + x; /* wrong */
        a = x + x; /* right */
        ++x;

        int ar[10];
        x = 0;
        ar[x] = x++; /* wrong */
        ar[x++] = x; /* wrong */
        ar[x] = x; /* right */
        ++x;
        return 0;
    }

Tenga en cuenta que también es una buena práctica utilizar operadores de publicación previa a publicación previa cuando se utiliza solo en una declaración. Mira el código anterior para esto.

Tenga en cuenta también que cuando se llama a una función, todos los efectos secundarios en los argumentos deben tener lugar antes de que se ejecute la función.

    int foo(int x)
    {
        return x;
    }

    int main()
    {
        int a = 42;
        int b = foo(a++);  /* This returns 43, even if it seems like it should return 42 */
        return 0;
    }