On pense généralement que la préposition ++ ajoute d'abord la valeur de la variable à 1, puis utilise la valeur après avoir ajouté 1 pour participer à l'opération; tandis que le post-position ++ utilise d'abord la valeur pour participer à l'opération, puis ajoute la valeur à 1.
Jetons un coup d'œil au premier exemple:
Test de package; classe publique plus_test01 {public static void main (String [] args) {int i = 100; i = i ++; System.out.println (i); }}Devinez quel est le résultat?
Regardons le deuxième:
Test de package; classe publique plus_test02 {public static void main (String [] args) {int k = 100; while (true) {if (k ++> 100) {// system.out.println (k); casser; } System.out.println (k); }}}Devinez quel est le résultat?
En fait, que ce soit pré-++ ou post-++, la valeur de la variable est d'abord augmentée de 1 avant de continuer à calculer. La vraie différence entre les deux est: le pré-++ ajoute la valeur de la variable par 1 et utilise la valeur ajoutée pour effectuer des calculs, tandis que le post - ++ attribue d'abord la variable à une variable temporaire, puis ajoute 1 à la valeur de la variable, puis utilise cette variable temporaire pour effectuer des calculs.
Pour l'extrait de code suivant (Prefix ++):
int i = 1;
int j = ++ i * 5;
En fait, la deuxième phrase équivaut à:
i + = 1; // ajoute i à 1
j = i * 5; // Calculez la valeur après avoir ajouté 1 avec lui, le résultat est: 10
Et pour l'extrait de code suivant (post - ++):
int i = 1;
int j = i ++ * 5;
La deuxième phrase est équivalente à:
int temp = i; // Attribuez I à une variable temporaire
i + = 1; // ajoute i à 1
J = temp * 5; // Calculez la variable temporaire avec lui, le résultat est: 5
Pour le premier exemple, il équivaut à:
int temp = i;
i + = 1;
i = temp; //
Le résultat doit donc être inchangé, c'est-à-dire 100.
Le code d'assemblage pour le premier exemple est:
public static void main (java.lang.string []); Descripteur: ([Ljava / Lang / String;) V Flags: ACC_PUBLIC, ACC_STATIC CODE: Stack = 2, Locals = 2, Args_Size = 1 0: Bipush 100 2: Istore_1 3: Iload_1 4: Iinc 1, 1 // Le second dans Var plus 1: Istore_1 // Save to Local var 8: Getstatic # 16 // Fiel java / lang / system.out: ljava / io / printStream; 11: Iload_1 // Le paramètre chargé est le deuxième de la pile, c'est-à-dire qu'il est toujours 100 12: invokevirtual # 22 // méthode java / io / printstream.println: (i) v 15: return
Pour le deuxième exemple, ce n'est en fait pas difficile, mais le résultat est 101. Faites attention au processus et vous ne pouvez pas faire de telles erreurs à l'avenir. (Le processus est: Comparez d'abord Temp = I, Temp> 100, ne tient évidemment pas True. Sautez I + = 1 à la phrase Syso, bien sûr, imprimez 101, à nouveau, et il y a aussi Temp = I, Temp> 100, cette fois, il est vrai, puis I + = 1, saute directement de la boucle directement, et la déclaration dans le cas où ne sera pas exécutée).
Compilation du deuxième exemple (seule la méthode principale est sélectionnée):
public static void main (java.lang.string []); Descripteur: ([Ljava / Lang / String;) V Flags: ACC_PUBLIC, ACC_STATIC CODE: Stack = 2, Locals = 2, Args_Size = 1 0: Bipush 100 // 100 Push Stack 2: istore_1 // 2 du VAR local (la variable locale augmente, le résultat est toujours dans le VAR local, le 1 supérieur de la pile d'opérande ne changera pas) 7: Bipush 100 // 100 Push Stack 9: if_icmple 15 // Comparez les deux valeurs INT INTEGER en haut de la pile d'opérande, si le premier est inférieur ou égal à la seconde, puis sur la pile de la pile de l'opérande. Top 2) 15: GetStatic # 2 // Field Java / Lang / System.out: ljava / io / printStream; 18: Iload_1 // // Chargement du premier var 19 local: invokevirtual # 3 // méthode java / io / printstream.println: (i) v // appelle cette méthode 22: goto 3 // sautez à nouveau à 3, boucle à nouveau 25: return // exiter
Le troisième exemple:
test de package; classe publique plus_test03 {static int proplus () {int i = 55; int j = ++ i; retour j; // 56} static int postplus () {int i = 55; int j = i ++; retour j; // 55} public static void main (String [] args) {System.out.println (proplus ()); // 56 System.out.println (postplus ()); // 55}}Compilation du troisième exemple:
statique int proplou (); Descripteur: () I Flags: ACC_STATIC CODE: Stack = 1, Locals = 2, args_size = 0 0: Bipush 55 // 55 Stack 2: istore_0 // Stockage en haut de la pile int à la première Var 3: Iinc 0, 1 // Le premier var plus local plus 1 6: ILOAD_0 // LOCE DE VAR 7: ISTORE_1 // Le haut de la pile est le deuxième var 9 local: ireTurnstatic int postplus (); Descripteur: () I Flags: ACC_STATIC CODE: Stack = 1, Locals = 2, Args_Size = 0 0: Bipush 55 2: istore_0 3: Iload_0 // Chargez à empiler 4: iinc 0, 1 // le premier var plus local 1 7: Istore_1 8: Iinc
On peut voir que la différence entre le front ++ et l'arrière ++ est la partie bleue ci-dessus (// le premier var plus local plus 1), qui sont le contraire. Pour le prédécesseur, le nombre dans le VAR local sera ajouté 1 puis chargé dans la pile, tandis que ce dernier sera chargé de la pile VAR local à la pile, puis le VAR local sera ajouté 1, ce qui équivaut à quitter une sauvegarde.
en conclusion:
un. La préposition et le post-position ++ ajoutent 1 à la valeur de la variable d'abord, au lieu d'ajouter 1 à la préposition ++ puis de calculer, tandis que le post-position ++ est d'abord en premier.
deux. À partir d'une parole programmatique, le post - ++ attribue d'abord la variable à une variable temporaire, puis ajoute la valeur de la variable de 1, puis utilise la variable temporaire pour participer à l'opération.
trois. Du point de vue de l'instruction, la valeur de la variable est poussée sur la pile avant d'exécuter l'instruction à valeur ajoutée (IINC). Après avoir exécuté l'instruction à valeur ajoutée, la valeur poussée sur la pile est utilisée.
J'espère que grâce à cet article, je comprendrai complètement la différence entre les opérations de préposition ++ et post-position ++. Merci pour votre soutien à ce site!