Opérateurs d’incrémentation et de décrémentation

#include  int main() { int x = 4, y, z; y = --x; z = x--; printf("%d %d %d", x, y, z); } 

Sortie: 2 3 3

Quelqu’un peut-il expliquer cela?
Et que signifie i =+ j (supposons que i = 1 et j = 2 )?

explication simple:

–x ou ++ x : la valeur sera modifiée après.

x– ou x ++ : la valeur sera modifiée avant

Explication détaillée:

–x ou ++ x : pré-décrémentation / incrémentation: effectuera d’abord l’opération de décrémentation ou d’incrémentation en premier lieu, puis affectera x.

x– ou x ++ : post: décrémentation / incrémentation : affectera d’abord la valeur de x, puis effectuera l’opération de décrémentation ou d’incrémentation ultérieure.

écrivons votre code dans un format plus agréable et parcourons votre code étape par étape, puis annotez-le pour vous montrer visuellement ce qui se passe:

 main() { //We declare the variables x, y and z, only x is given a value of 4. int x=4,y,z; //--x will decrement var x by 1 first THEN it will assign the value of x to y. //so: x = 3, y = 3 and z = nothing yet. y = --x; //x-- will assign the value of x to z first, then var x will be decremented by 1 after. //so: x = 2, y=3 and z = 3 z = x--; printf ("\n %d %d %d", x,y,z); } 

y = --x signifie “diminuer x de un, puis stocker le résultat dans y”

z = x-- signifie “enregistrer une temp de x. Réduire x de un. Stocker la valeur de temp dans z”

Par conséquent:

  • x commence à 4.
  • Il est diminué de 1 (à 3). 3 est stocké dans y.
  • x est enregistré dans un temp. x est diminué à nouveau (à 2). alors la temp (3) est stockée dans z.
  • y et z sont imprimés en 3, x en 2.

L’opérateur de décrément postfixe (x–) renvoie la valeur de la variable avant qu’elle ne soit décrémentée.

  • x = 2, parce que vous l’avez décrémenté deux fois.
  • y = 3, parce que vous l’avez affecté à la valeur de x après sa décrémentation de 4
  • z = 3, car vous l’avez affectée à la valeur de x avant qu’elle ne soit décrémentée de 3.

Vous devez comprendre les notions d’opérateur de post-décrémentation et de pré-décrémentation.

Les deux vont décrémenter votre variable, mais l’un d’eux retournera la valeur originale ( x-- ) et l’un d’eux renverra la valeur décrémentée ( --x ).

Postfix decrement (x–) est différent du préfixe decrement (–x). Les premiers renvoient la valeur x, puis la décrémentent; ce dernier décrémente puis renvoie la valeur.

Et si vous voyez comment un postfix est écrit à bas niveau, vous constaterez que c’est un peu plus lent que le préfixe … 🙂

 y = --x; 

X est décrémenté, puis Y est affecté de la valeur de X (3)

 z = x--; 

Z est atsortingbué à la valeur de X (3), le X est décrémenté (2)

Oui:

x = 4
y = pré-décrémentation x (décrémente de 1 puis assigne, c.-à-d. y = x-1 = 3
x = 3
z = post-décrémentation x (décrément de 1 après avoir affecté la valeur, c.-à-d. z = x = 3, alors x = x – 1
x = 2

Donc x = 2, y = 3, z = 3, exactement ce que vous avez vu.

Si l’opérateur est un préfixe, l’incrémentation a lieu avant l’affectation, si l’opérateur est un suffixe, l’incrémentation a lieu après l’affectation.

Soit ** un opérateur d’incrémentation / décrémentation. **e signifie appliquer ** à e et évaluer le résultat alors que e** signifie évaluer e et ensuite appliquer ** à celui-ci .

Donc, si décrémentation et évaluation sont séparées, le code se lit comme suit:

 int x=4,y,z; x-=1;//3 y = x;//3 z = x;//3 x-=1;//2 

qui vous donne le rendement que vous avez;)

  • x ++ / x– est appelé post- incrémentation / décrémentation (valeur modifiée après …)
  • ++ x / ++ x est appelé pré- incrémentation / décrémentation (valeur modifiée avant …)

Voici ce qui se passe (à peu près) dans votre exemple:

 int x=4,y,z; // declare x=4, y=0, z=0 y = --x; // decrement x then assign it to y (pre decrement) (y=x=3) z = x--; // assign x to z then decrement x (post decrement) (z=3 and x=2) printf ("\n %d %d %d", x,y,z); // output 2 3 3 

Un pré-incrément / décrément ressemble à ceci en pseudocode

 read value increment/decrement value write value assign value 

et un post incrémentation / décrémentation ressemble à ceci

 read value assign value increment/decrement value write value 
 #include main () { int x=4,y,z; y = --x; z = x--; printf ("\n %d %d %d", x,y,z); } 

sortie 2,3,3 …………………………… première fois x = 4 bien. y = – x, la valeur moyenne de x est décrémentée de 1 et stockée dans y, donc maintenant y = 3 et x vaut également 3. alors z = x– signifie que la valeur de x est stockée dans z (z = 3) et alors x est décrémenté, à savoir maintenant x = 2 mais z = 3. Lorsque vous imprimez la valeur, alors printf () affiche 2 3 3

Parler de ce que i=+j; signifie (étant donné i = 1 et j = 2)

i=+j; est équivalent à i=i+j; alors votre expression devient i=1+2 c’est-à-dire i=3