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

que se passe-t-il (derrière les rideaux) quand ceci est exécuté?

int x = 7;
x = x++;

C'est-à-dire quand une variable est incrémentée et assignée à elle-même dans un énoncé? J'ai compilé et exécuté. x est toujours 7 même après la déclaration complète . Dans mon livre, il est dit que x est incrémenté!

255
demandé sur Nayuki 2011-10-27 08:39:33
la source

17 ответов

x est incrémenté. Mais vous assignez l'ancienne valeur de x de nouveau en elle-même.


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

ainsi à la fin, x est attribué à sa valeur initiale.

274
répondu Mysticial 2018-09-23 18:54:24
la source
x = x++;

est l'équivalent de

int tmp = x;
x++;
x = tmp;
369
répondu Prince John Wesley 2011-10-27 23:02:07
la source

La déclaration:

x = x++;

est l'équivalent de:

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.

en bref, la déclaration n'a pas d'effet.

Les points-clé:

  • La valeur d'un Postfix augmentation/diminution de l'expression est la valeur de l'opérande avant l'incrément/décrément. (Dans le cas d'un Préfixe, la valeur est la valeur de l'opérande après l'opération,)

  • L'ERS d'une expression d'affectation est entièrement évaluée (y compris les incréments, décréments et/ou autres effets secondaires) avant la valeur est attribuée à l'ERS.

notez que contrairement à C++, L'ordre d'évaluation D'une expression en Java est totalement spécifié et il n'y a pas de place pour 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 courant. Dans ce cas, un compilateur serait autorisé à optimiser l'ensemble de la déclaration parce qu'il peut être prouvé que c'est un no-op.


dans le cas où il 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 déclarations qui combinent Auto inc / décrément et assignation sur la même variable sont difficiles à comprendre, et par conséquent devrait être évitée indépendamment de leur exactitude . Il n'y a pas besoin d'écrire du code comme ça.

espérons, vérificateurs de code comme FindBugs et PMD signaleront le code comme ça comme suspect.

256
répondu Stephen C 2012-12-05 14:00:06
la source
int x = 7;
x = x++;

il a un comportement non défini dans C et pour Java voir cette réponse . Cela dépend du compilateur de ce qui se passe.

33
répondu user712092 2017-05-23 15:10:34
la source

une construction comme x = x++; indique que vous vous méprenez probablement sur 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) ce que vous vouliez:

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

la subtilité ici est que le ++ opérateur modifie la variable x , contrairement à une expression comme x + x , qui évaluerait à une valeur int mais laisserait la variable x elle-même inchangée. Considérez une construction comme la vénérable for boucle:

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

vous avez remarqué le i++ ? C'est le même opérateur. Nous pourrions réécrire cette boucle for 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 recommande également de ne pas utiliser le ++ opérateur dans des expressions plus larges dans la plupart des cas. En raison de la subtilité de quand il modifie la variable originale dans pré - versus post-increment ( ++x et x++ , respectivement), il est très facile d'introduire des bogues subtils qui sont difficiles à traquer.

16
répondu FMM 2012-09-10 18:17:33
la source

selon le code D'octet obtenu à partir des fichiers de classe,

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

Dans Case1 , Pousser se produit (et puis plus tard attribué) avant de l'incrément (signifie essentiellement que votre augmentation n'est rien)

dans Case2 , L'incrément se produit d'abord (ce qui fait 8) et ensuite poussé sur la pile(et ensuite assigné à x)

Cas 1:

int x=7;
x=x++;

Byte Code:

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

affaire 2:

int x=7; 
x=++x;

Byte Code

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
  • "1519370920 Pile" se réfère ici à des Opérandes de Pile, local: x index: 1 type: int
11
répondu EvenPrime 2014-08-28 19:22:40
la source

C'est incrémenté après " x = x++; ". Il serait 8 si vous l'avez fait " x = ++x; ".

9
répondu F.J 2011-11-02 18:43:16
la source

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

8
répondu JonPM 2011-10-27 08:43:14
la source

quand vous assignez de nouveau la valeur pour x il est encore 7. Essayez x = ++x et vous obtiendrez 8 sinon faites

x++; // don't re-assign, just increment
System.out.println(x); // prints 8
8
répondu Vishal 2011-11-02 18:43:43
la source

parce que x++ incrémente la valeur après l'avoir assignée à la variable. ainsi de suite et pendant l'exécution de cette ligne:

x++;

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

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

vous donnera 8.

si vous voulez utiliser une valeur incrémentée de x sur votre énoncé d'affectation, utilisez

++x;

cela augmentera x par 1, puis assignez cette valeur à la variable X.

[Edit] au lieu de x++, c'est juste x++; le premier attribue la valeur originale de x à lui-même, donc il ne fait rien sur cette ligne.

7
répondu josephus 2012-03-13 06:29:51
la source

Post opérateur d'Incrémentation fonctionne comme suit:

  1. stocker la valeur antérieure de l'opérande.
  2. incrémente la valeur de l'opérande.
  3. renvoie la valeur précédente de l'opérande.

l'instruction

int x = 7;
x = x++; 

serait évalué comme suit:

  1. x est initialisé avec la valeur 7
  2. post l'opérateur d'incrément stocke la valeur précédente de x, c.-à-d. 7 à retourner.
  3. incréments le x, donc maintenant x est 8
  4. renvoie la valeur précédente de x i.e. 7 et elle est assignée de nouveau à x, donc x redevient 7

donc x est en effet augmenté mais puisque x++ renvoie le résultat à x, la valeur de x est donc dépassée par sa valeur précédente.

5
répondu GauravLuthra 2015-09-14 18:31:27
la source

que se passe-t-il quand int x = 7; x = x++; ?

ans -> x++ signifie d'abord l'utilisation de la valeur de x pour l'expression et puis l'augmenter de 1.

C'est ce qui se passe dans votre cas. La valeur de x sur RHS est copiée à la variable x sur LHS et la valeur de x est augmentée de 1.

de même ++x signifie -> augmenter la valeur de x d'abord par un et ensuite utiliser dans l'expression .

Donc dans votre cas si vous faites x = ++x ; // where x = 7

vous obtiendrez une valeur de 8.

pour plus de clarté, essayez de savoir combien d'instruction printf exécutera le code suivant

while(i++ <5)   
  printf("%d" , ++i);   // This might clear your concept upto  great extend
4
répondu samprat 2011-11-02 18:44:20
la source

++x est pré-incrément -> x est incrémenté avant utilisé

x++ est la post-incrémentation -> x est incrémenté après utilisé

int x = 7; -> x get 7 value <br>
x = x++; -> x get x value AND only then x is incremented
4
répondu Roberto Martelloni 2011-11-02 18:45:02
la source

donc ça veut dire: x++ n'est pas égal à x = x+1

parce que:

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

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

et maintenant il semble un peu étrange:

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

très dépendant du compilateur!

2
répondu linuxeasy 2011-10-27 17:27:13
la source

je pense que cette controverse peut être résolue sans entrer dans le code & la simple pensée.

Considérer i++ et ++j'ai comme des fonctions, dire Func1 & Func2.

Now 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 à 8, mais sur remplir la fonction retourne 7.

donc finalement 7 est attribué à I. (Donc à la fin, i = 7)

0
répondu Pranav Mahajan 2017-12-23 01:50:33
la source

x = x++;

ici l'opérateur de post-incrément. Il doit être compris comme"utiliser la valeur de l'opérande et ensuite incrémenter l'opérande".

si vous voulez que l'inverse se produise I. e "incrémenter l'opérande et ensuite utiliser la valeur de l'opérande", vous devez utiliser l'opérateur pre-increment comme indiqué ci-dessous.

x = ++x;

cet opérateur incrémente d'abord la valeur de x par 1 et assigne ensuite la valeur retour to X.

-1
répondu deepak 2014-12-14 08:50:34
la source

c'est parce que vous avez utilisé un opérateur post-increment. Dans la ligne de code suivante

x = x++;

ce qui se passe, c'est que vous assignez la valeur de x à X. x++ incréments x après que la valeur de x est assignée à X. C'est ainsi que les opérateurs post-incrément travaillent. Ils travaillent après qu'une déclaration a été exécutée. Donc dans votre code, x est retourné d'abord après, puis il est incrémenté.

Si vous l'avez fait

x = ++x;

la réponse serait 8 parce que vous avez utilisé l'opérateur de pré-incrément. Ceci augmente la valeur avant de retourner la valeur de X.

-1
répondu Anon 2018-03-14 10:37:50
la source

Autres questions sur java operators post-increment