La différence entre ++ Var et Var ++

En programmation, notamment en Java, quelle est la différence entre:

int var = 0; var++; 

et

 int var = 0; ++var; 

Quelles répercussions cela aurait-il sur une boucle?

par exemple

 for (int i = 0; i < 10; i++) {} for (int i = 0; i < 10; ++i) {} 

tldr;

Bien que var++ et ++var incrémentent la variable à laquelle ils sont appliqués, le résultat renvoyé par var++ est la valeur de la variable avant l’incrémentation, tandis que le résultat renvoyé par ++var est la valeur de la variable après l’application de l’incrément.

Plus d’explications

Lorsque ++var ou var++ forment une instruction complète (comme dans vos exemples), il n’y a pas de différence entre les deux. Par exemple le suivant

 int x = 6; ++x; assert x == 7; 

est identique à

 int x = 6; x++; assert x == 7; 

Cependant, lorsque ++var ou var++ sont utilisés dans le cadre d’une instruction plus volumineuse, les deux peuvent ne pas être équivalents. Par exemple, l’assertion suivante passe

 int x = 6; assert ++x == 7; 

alors que celui-ci échoue

 int x = 6; assert x++ == 7; 

Bien que var++ et ++var incrémentent la variable à laquelle ils sont appliqués, le résultat renvoyé par var++ est la valeur de la variable avant l’incrémentation, tandis que le résultat renvoyé par ++var est la valeur de la variable après l’application de l’incrément.

Lorsqu’il est utilisé dans une boucle for , il n’y a pas de différence entre les deux car l’incrémentation de la variable ne fait pas partie d’une instruction plus grande. Cela peut ne pas apparaître de cette façon, car il existe un autre code sur la même ligne du fichier source. Mais si vous regardez attentivement, vous verrez qu’il y a un ; immédiatement avant l’incrémentation et rien après, l’opérateur d’incrémentation ne fait donc pas partie d’une instruction plus grande.

++var est l’opérateur de pré-incrémentation; il incrémente la valeur de var avant d’ évaluer l’expression. De même, var++ est l’opérateur de post-incrémentation; il incrémente la valeur de var après avoir évalué l’expression.

Dans le cas d’une boucle simple, il n’y a pas de différence entre deux, car les expressions ++var; et var++; les deux cèdent au même résultat.

Pour plus d’informations, voir par exemple http://www.particle.kth.se/~lindsey/JavaCourse/Book/Part1/Java/Chapter02/operators.html#IncDecOps .

int a = 5, b;

post incrémentation : b = a++; : a est d’abord transféré à b puis a est incrémenté, donc maintenant b est 5 , et a est 6 L’effet est b = a; a = a + 1; b = a; a = a + 1;

pré incrémentation : b = ++a; : d’abord a est incrémenté puis le résultat est transféré dans b , donc maintenant a 7 et aussi b est 7 . L’effet est a = a + 1; b = a a = a + 1; b = a

a++ et ++a restr indépendamment agissent de la même manière. Dans les exemples de boucles que vous avez présentés, les opérateurs d’incrément ne sont associés à aucune expression et sont indépendants. Par conséquent, ces deux dans cette implémentation particulière est identique.

Dans vos exemples, il n’y a pas de différence, il y a cependant une différence entre:

 int var = 0; int var2 = ++var; 

et:

 int var = 0; int var2 = var++; 

Dans le premier cas, la valeur de var2 est 1 alors que dans le second, elle vaut 0.

var ++ renvoie sa valeur avant l’incrémentation.
++ var renvoie sa valeur après l’incrémentation.

 int var = 0; System.out.println(var++); // returns 0; var = 0; System.out.println(++var); // returns 1 

++ i est préincrément, il se fait avant tout dans l’expression qu’il apparaît.

i ++ est postdécrement, il se fait après tout ce qui apparaît dans l’expression.

dans la première boucle, vous passerez de 0 à 9. Dans la seconde, il ira de 1 à 9.

Mon conseil: évitez les deux (les exceptions peuvent être i ++ ou la première boucle). Trop délicat à rechercher dans l’expression.

J’ai passé une longue journée de débogage

myArray [(i ++)% 16] = données

et essayer de trouver pourquoi il a essayé d’écrire sur des données [16] parfois

En fait, c’est plutôt simple. Le preincrement ++ i est exécuté en premier dans l’instruction.

 j = ++i +1; 

est équivalent à

 i = i+1; j = i+1; 

tandis que l’incrément de poste i ++ est exécuté à la fin;

 j = i++ +1; 

est équivalent à

 j = i+1; i = i+1; 

++var et var++ sont tous deux identiques lorsqu’ils apparaissent dans une expression uniquement. Cela s’applique à votre question parce que vous avez seul ++i , i++

La différence ne se produit que lorsque vous les intégrez:

 int x = 0; printf( "%d %d\n", ++x, x ); // 1 1 printf( "%d %d\n", x++, x ); // 1 2 

Comment se souvenir?

Lorsque vous voyez d’ abord l’opérateur, puis l’incrémenter et prendre plus tard sa valeur.

Lorsque vous voyez en premier la variable, alors prenez la valeur et incrémentez plus tard.

Donc, dans le premier exemple, vous voyez des valeurs égales parce que:

 you increment `x`, then access `x`, then access `x` again 

Donc, dans le deuxième exemple, vous voyez des différences parce que:

 you access `x`, then increment `x`, then access `x` again