Qu'est-ce que x après «x = x ++»?

Que se passe-t-il (derrière les rideaux) lorsque cela est exécuté?

int x = 7;
x = x++;

Autrement dit, lorsqu'une variable est post-incrémentée et affectée à elle-même dans une seule instruction? J'ai compilé et exécuté cela. xest toujours 7 même après la déclaration entière . Dans mon livre, il est dit que xc'est incrémenté!

xest incrémenté. Mais vous attribuez l'ancienne valeur de xretour en soi.

x = x++;

1. x++ incréments x et renvoie son ancienne valeur.
2. x = assigne l'ancienne valeur à lui-même.

Donc à la fin, x revient à sa valeur initiale.

x = x++;

est équivalent à

int tmp = x;
x++;
x = tmp;

La déclaration:

x = x++;

est équivalent à:

tmp = x;   // ... this is capturing the value of "x++"
x = x + 1; // ... this is the effect of the increment operation in "x++" which
           //     happens after the value is captured.
x = tmp;   // ... this is the effect of assignment operation which is
           //     (unfortunately) clobbering the incremented value.

Bref, la déclaration n'a aucun effet.

Les points clés:

• La valeur d'une expression d'incrémentation / décrémentation de Postfix est la valeur de l'opérande avant que l'incrémentation / décrémentation n'ait lieu. (Dans le cas d'un formulaire Prefix, la valeur est la valeur de l'opérande après l'opération,)

• le RHS d'une expression d'affectation est complètement évalué (y compris tous les incréments, décréments et / ou autres effets secondaires) avant que la valeur ne soit affectée au LHS.

_{Notez que contrairement à C et C ++, l'ordre d'évaluation d'une expression en Java est totalement spécifié et il n'y a pas de place pour une variation spécifique à la plate-forme. Les compilateurs ne sont autorisés à réorganiser les opérations que si cela ne change pas le résultat de l'exécution du code du point de vue du thread actuel. Dans ce cas, un compilateur serait autorisé à optimiser l'intégralité de l'instruction car il peut être prouvé qu'il s'agit d'un no-op.}

Au cas où ce n'est pas déjà évident:

• "x = x ++;" est presque certainement une erreur dans n'importe quel programme.
• L'OP (pour la question d'origine!) Signifiait probablement "x ++;" plutôt que "x = x ++;".
• Les instructions qui combinent auto inc / décrémentation et affectation sur la même variable sont difficiles à comprendre et doivent donc être évitées quelle que soit leur exactitude . Il n'est tout simplement pas nécessaire d'écrire du code comme ça.

Espérons que les vérificateurs de code comme FindBugs et PMD signaleront ce code comme suspect.

int x = 7;
x = x++;

Il a un comportement indéfini en C et pour Java voir cette réponse . Cela dépend du compilateur ce qui se passe.

Une construction comme x = x++;indique que vous comprenez probablement mal ce que fait l' ++opérateur:

// original code
int x = 7;
x = x++;

Réécrivons ceci pour faire la même chose, basé sur la suppression de l' ++opérateur:

// behaves the same as the original code
int x = 7;
int tmp = x; // value of tmp here is 7
x = x + 1; // x temporarily equals 8 (this is the evaluation of ++)
x = tmp; // oops! we overwrote y with 7

Maintenant, réécrivons-le pour faire (ce que je pense) que vous vouliez:

// original code
int x = 7;
x++;

La subtilité ici est que l' ++opérateur modifie la variablex , contrairement à une expression telle que x + x, qui évaluerait une valeur int mais laisserait la variable xelle-même inchangée. Considérons une construction comme la forboucle vénérable :

for(int i = 0; i < 10; i++)
{
    System.out.println(i);
}

Remarquez le i++dedans? C'est le même opérateur. Nous pourrions réécrire cette forboucle comme ceci et elle se comporterait de la même manière:

for(int i = 0; i < 10; i = i + 1)
{
    System.out.println(i);
}

Je déconseille également d'utiliser l' ++opérateur dans des expressions plus grandes dans la plupart des cas. En raison de la subtilité du moment où il modifie la variable d'origine avant et après l'incrémentation ( ++xet x++respectivement), il est très facile d'introduire des bogues subtils difficiles à localiser.

Selon le code d'octet obtenu à partir des fichiers de classe,

Les deux affectations incrémentent x, mais la différence est le moment de when the value is pushed onto the stack

Dans Case1 , Push se produit (puis est ensuite attribué) avant l'incrément (ce qui signifie essentiellement que votre incrément ne fait rien)

Dans Case2, l'incrémentation se produit d'abord (ce qui en fait 8) puis poussé sur la pile (puis affecté à x)

Cas 1:

int x=7;
x=x++;

Code d'octet:

0  bipush 7     //Push 7 onto  stack
2  istore_1 [x] //Pop  7 and store in x
3  iload_1  [x] //Push 7 onto stack
4  iinc 1 1 [x] //Increment x by 1 (x=8)
7  istore_1 [x] //Pop 7 and store in x
8  return       //x now has 7

Cas 2:

int x=7; 
x=++x;

Code d'octet

0  bipush 7     //Push 7 onto stack
2  istore_1 [x] //Pop 7 and store in x
3  iinc 1 1 [x] //Increment x by 1 (x=8)
6  iload_1  [x] //Push x onto stack
7  istore_1 [x] //Pop 8 and store in x
8  return       //x now has 8

• La pile ici fait référence à la pile d'opérandes, locale: index x: 1 type: int

Il est incrémenté après " x = x++;". Ce serait 8 si vous faisiez " x = ++x;".

L'opérateur Post Increment fonctionne comme suit:

1. Stocke la valeur précédente de l'opérande.
2. Incrémentez la valeur de l'opérande.
3. Renvoie la valeur précédente de l'opérande.

Donc, la déclaration

int x = 7;
x = x++; 

serait évalué comme suit:

1. x est initialisé avec la valeur 7
2. L'opérateur post incrément stocke la valeur précédente de x, c'est-à-dire 7 à renvoyer.
3. Incrémente le x, alors maintenant x est 8
4. Renvoie la valeur précédente de x, c'est-à-dire 7 et elle est affectée à nouveau à x, donc x redevient 7

Donc x est en effet augmenté mais comme x ++ assigne le résultat à x, la valeur de x est remplacée par sa valeur précédente.

L'incrémentation se produit après l'appel de x, donc x est toujours égal à 7. ++ x serait égal à 8 lorsque x est appelé

Lorsque vous réattribuez la valeur, xelle est toujours de 7. Essayez x = ++xet vous obtiendrez 8 autres choses

x++; // don't re-assign, just increment
System.out.println(x); // prints 8

car x ++ incrémente la valeur APRÈS l'affectation à la variable. ainsi de suite et pendant l'exécution de cette ligne:

x++;

le varialbe x aura toujours la valeur d'origine (7), mais en utilisant à nouveau x sur une autre ligne, comme

System.out.println(x + "");

vous donnera 8.

si vous souhaitez utiliser une valeur incrémentée de x dans votre instruction d'affectation, utilisez

++x;

Cela incrémentera x de 1, PUIS attribuez cette valeur à la variable x.

[Modifier] au lieu de x = x ++, c'est juste x ++; l'ancien attribue la valeur d'origine de x à lui-même, donc il ne fait rien sur cette ligne.

Ce qu'il se passe quand int x = 7; x = x++; ?

ans -> x++signifie d'abord utiliser la valeur de x pour l'expression, puis l'augmenter de 1.
C'est ce qui se passe dans votre cas. La valeur de x sur RHS est copiée dans la variable x sur LHS, puis la valeur dex est augmentée de 1.

De la même ++x manière, ->augmenter d'abord la valeur de x de un, puis l'utiliser dans l'expression.
Donc, dans votre cas, si vous le faites, x = ++x ; // where x = 7
vous obtiendrez une valeur de 8.

Pour plus de clarté, essayez de savoir combien d'instructions printf exécuteront le code suivant

while(i++ <5)   
  printf("%d" , ++i);   // This might clear your concept upto  great extend

++xest pré-incrémenté ->x est incrémenté avant d' être utilisé
x++est post-incrémenté ->x est incrémenté après avoir été utilisé

int x = 7; -> x get 7 value <br>
x = x++; -> x get x value AND only then x is incremented

Cela signifie donc: x++n'est pas égal àx = x+1

car:

int x = 7; x = x++;
x is 7

int x = 7; x = x = x+1;
x is 8

et maintenant ça semble un peu étrange:

int x = 7; x = x+=1;
x is 8

très dépendant du compilateur!

x = x ++;

Il s'agit de l'opérateur post-incrémentation. Il doit être compris comme "Utilisez la valeur de l'opérande puis incrémentez l'opérande".

Si vous souhaitez que l'inverse se produise, c'est-à-dire "Incrémenter l'opérande puis utiliser la valeur de l'opérande", vous devez utiliser l'opérateur de pré-incrémentation comme indiqué ci-dessous.

x = ++ x;

Cet opérateur incrémente d'abord la valeur de x de 1, puis attribue la valeur à x.

Je pense que cette controverse peut être résolue sans entrer dans le code et juste penser.

Considérez i ++ et ++ i comme des fonctions, par exemple Func1 et Func2.

Maintenant i = 7;
Func1 (i ++) renvoie 7, Func2 (++ i) renvoie 8 (tout le monde le sait). En interne, les deux fonctions incrémentent i à 8, mais elles renvoient des valeurs différentes.

Donc i = i ++ appelle la fonction Func1. À l'intérieur de la fonction, i augmente jusqu'à 8, mais une fois terminée, la fonction renvoie 7.

Donc, finalement, 7 est alloué à i. (Donc au final, i = 7)

En effet, vous avez utilisé un opérateur de post-incrémentation. Dans cette ligne de code suivante

x = x++;

Ce qui se passe, c'est que vous attribuez la valeur de x à x. x ++ incrémente x une fois que la valeur de x est affectée à x. C'est ainsi que fonctionnent les opérateurs post-incrémentation. Ils travaillent après l'exécution d'une déclaration. Ainsi, dans votre code, x est retourné d'abord après, puis il est ensuite incrémenté.

Si tu l'as fait

x = ++x;

La réponse serait 8 car vous avez utilisé l'opérateur de pré-incrémentation. Cela incrémente la valeur avant de renvoyer la valeur de x.