Comment les opérateurs post increment (i ++) et pré incrémentation (++ i) fonctionnent-ils en Java?
Pouvez-vous m'expliquer la sortie de ce code Java?
int a=5,i;
i=++a + ++a + a++;
i=a++ + ++a + ++a;
a=++a + ++a + a++;
System.out.println(a);
System.out.println(i);
La sortie est 20 dans les deux cas
Est-ce que cela aide?
a = 5;
i=++a + ++a + a++; =>
i=6 + 7 + 7; (a=8)
a = 5;
i=a++ + ++a + ++a; =>
i=5 + 7 + 8; (a=8)
Le point principal est que ++a incrémente la valeur et la renvoie immédiatement.
a++ incrémente également la valeur (en arrière-plan) mais renvoie la valeur inchangée de la variable - ce qui semble être exécuté ultérieurement.
++a incrémente puis utilise la variable.a++ utilise puis incrémente la variable.
Si tu as
a = 1;
et vous faites
System.out.println(a++); //You will see 1
//Now a is 2
System.out.println(++a); //You will see 3
codaddict explique votre extrait particulier.
Dans les deux cas, il calcule d’abord la valeur, mais en post-incrément, il conserve l’ancienne valeur et, après le calcul, la renvoie
++ a
- a = a + 1;
- retourne un;
a ++
- temp = a;
- a = a + 1;
- retour temp;
i = ++a + ++a + a++;
est
i = 6 + 7 + 7
Actif : incrémenter a à 6 (valeur actuelle 6) + incrémenter a à 7 (valeur actuelle 7). La somme est 13, ajoutez-la à la valeur actuelle de a (= 7), puis incrémentez a de 8. La somme est 20 et la valeur de a une fois l’affectation terminée est 8.
i = a++ + ++a + ++a;
est
i = 5 + 7 + 8
Fonctionne : Au début, la valeur de a est 5. Utilisez-la dans l'addition, puis augmentez-la à 6 (valeur actuelle 6). Incrémentez a de la valeur actuelle 6 à 7 pour obtenir un autre opérande de +. La somme est 12 et la valeur actuelle de a est 7. Incrémentez ensuite a de 7 à 8 (valeur actuelle = 8) et ajoutez-le à la somme 12 précédente pour obtenir 20.
++a incrémente a avant son évaluation .a++ évalue a puis l'incrémente.
Relatif à votre expression donnée:
i = ((++a) + (++a) + (a++)) == ((6) + (7) + (7)); // a is 8 at the end
i = ((a++) + (++a) + (++a)) == ((5) + (7) + (8)); // a is 8 at the end
Les parentes que j'ai utilisées ci-dessus sont implicitement utilisées par Java. Si vous regardez les termes de cette façon, vous pouvez facilement voir qu'ils sont identiques et commutatifs.
Dans l'exemple ci-dessus
int a = 5,i;
i=++a + ++a + a++; //Ans: i = 6 + 7 + 7 = 20 then a = 8
i=a++ + ++a + ++a; //Ans: i = 8 + 10 + 11 = 29 then a = 11
a=++a + ++a + a++; //Ans: a = 12 + 13 + 13 = 38
System.out.println(a); //Ans: a = 38
System.out.println(i); //Ans: i = 29
++ a est l'opérateur d'incrément de préfixe:
- le résultat est calculé et stocké en premier,
- alors la variable est utilisée.
a ++ est l'opérateur d'incrément postfix:
- la variable est utilisée en premier,
- alors le résultat est calculé et stocké.
Une fois que vous vous souvenez des règles, EZ pour tout calculer!
En supposant que vous vouliez dire
int a=5; int i;
i=++a + ++a + a++;
System.out.println(i);
a=5;
i=a++ + ++a + ++a;
System.out.println(i);
a=5;
a=++a + ++a + a++;
System.out.println(a);
Ceci évalue à:
i = (6, a is now 6) + (7, a is now 7) + (7, a is now 8)
donc i est 6 + 7 + 7 = 20 et donc 20 est imprimé.
i = (5, a is now 6) + (7, a is now 7) + (8, a is now 8)
donc i est 5 + 7 + 8 = 20 et donc 20 est imprimé à nouveau.
a = (6, a is now 6) + (7, a is now 7) + (7, a is now 8)
et après que tout le côté droit ait été évalué (y compris le réglage de a sur 8) ALORS a est défini sur 6 + 7 + 7 = 20 et ainsi 20 est imprimé une dernière fois.
lorsque a vaut 5, alors a++ donne un 5 à l'expression et incrémente a par la suite, tandis que ++a incrémente a avant de passer le nombre à l'expression (ce qui donne a 6 à l'expression dans ce cas).
Alors tu calcules
i = 6 + 7 + 7
i = 5 + 7 + 8
Je pense cependant que si vous combinez toutes vos déclarations et que vous l'exécutez en Java 8.1, vous obtiendrez une réponse différente, du moins c'est ce que mon expérience dit.
Le code fonctionnera comme ceci:
int a=5,i;
i=++a + ++a + a++; /*a = 5;
i=++a + ++a + a++; =>
i=6 + 7 + 7; (a=8); i=20;*/
i=a++ + ++a + ++a; /*a = 5;
i=a++ + ++a + ++a; =>
i=8 + 10 + 11; (a=11); i=29;*/
a=++a + ++a + a++; /*a=5;
a=++a + ++a + a++; =>
a=12 + 13 + 13; a=38;*/
System.out.println(a); //output: 38
System.out.println(i); //output: 29
La pré-incrémentation signifie que la variable est incrémentée AVANT d'être évaluée dans l'expression. Post-incrémentation signifie que la variable est incrémentée APRÈS qu'elle a été évaluée pour utilisation dans l'expression.
Par conséquent, regardez bien et vous verrez que les trois tâches sont arithmétiquement équivalentes.
Je crois que vous exécutez toutes ces déclarations différemment
exécuter ensemble aboutira => 38, 29
int a=5,i;
i=++a + ++a + a++;
//this means i= 6+7+7=20 and when this result is stored in i,
//then last *a* will be incremented <br>
i=a++ + ++a + ++a;
//this means i= 5+7+8=20 (this could be complicated,
//but its working like this),<br>
a=++a + ++a + a++;
//as a is 6+7+7=20 (this is incremented like this)
a=5; i=++a + ++a + a++;
est
i = 7 + 6 + 7
Fonctionne: la pré-post-incrémentation a une associativité "de droite à gauche" et la priorité de pré-est sur post, donc la pré-incrémentation sera résolue d'abord comme (++a + ++a) => 7 + 6. alors a=7 est fourni pour poster increment => 7 + 6 + 7 =20 et a =8.
a=5; i=a++ + ++a + ++a;
est
i=7 + 7 + 6
Actif: pré/post-incrémentation "de droite à gauche", associativité, et pré a priorité sur post, donc tout d'abord pré-incrémentation sera résolue en tant que (++a + ++a) => 7 + 6, puis a=7 est fourni pour post increment => 7 + 7 + 6 =20 et a =8.
pré-incrémentation et post-incrémentation sont équivalentes sinon dans une expression
int j =0;
int r=0
for(int v = 0; v<10; ++v) {
++r;
j++;
System.out.println(j+" "+r);
}
1 1
2 2
3 3
4 4
5 5
6 6
7 7
8 8
9 9
10 10