C Language
Skutki uboczne

Operatory Pre / Post Increment / Decrement

W C istnieją dwa jednoargumentowe operatory - „++” i „-”, które są bardzo powszechnym źródłem nieporozumień. Operator ++ nazywany jest operatorem inkrementacji, a operator -- operatorem dekrementacji . Oba mogą być używane zarówno w formie przedrostka, jak i postfiksu . Składnia formularza przedrostka dla operatora ++ to ++operand a składnia formularza przedrostka to operand++ . W przypadku użycia w postaci prefiksu operand jest najpierw zwiększany o 1 a wynikowa wartość operandu jest wykorzystywana do oceny wyrażenia. Rozważ następujący przykład:

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 ; */

W przypadku zastosowania Postfiksa bieżąca wartość argumentu jest używana w wyrażeniu, a następnie wartość argumentu jest zwiększana o 1 . Rozważ następujący przykład:

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; */

Działanie operatora dekrementacji -- może być rozumiane podobnie.

Poniższy kod pokazuje, co każdy z nich robi

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

Z powyższego jasno wynika, że operatorzy pocztowi zwracają bieżącą wartość zmiennej, a następnie ją modyfikują, ale operatorzy wstępni modyfikują zmienną, a następnie zwracają zmodyfikowaną wartość.

We wszystkich wersjach C kolejność oceny operatorów przed i po nie jest zdefiniowana, dlatego następujący kod może zwrócić nieoczekiwane dane wyjściowe:

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

Należy pamiętać, że dobrą praktyką jest również stosowanie operatorów pre-post, gdy są one używane osobno w instrukcji. Spójrz na powyższy kod.

Zauważ też, że kiedy funkcja jest wywoływana, wszystkie efekty uboczne argumentów muszą wystąpić przed uruchomieniem funkcji.

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