Quelle est la différence entre X = X ++? vs X ++ ;?

Question

Avez-vous déjà essayé cela auparavant?

 static void Main(string[] args)
{
    int x = 10;
    x = x++;
    Console.WriteLine(x);
}
 

Sortie: 10

mais pour

 static void Main(string[] args)
{
    int x = 10;
    x++;
    Console.WriteLine(x);
}
 

Sortie: 11.

Quelqu'un pourrait-il expliquer pourquoi?

Answer 1

X ++ incrémentera la valeur, mais renverra ensuite l'ancienne valeur.

Donc dans ce cas:

 static void Main(string[] args)
{
    int x = 10;
    x = x++;
    Console.WriteLine(x);
}
 

Vous avez X à 11 juste pour un moment, puis il revient à 10 car 10 est la valeur de retour de (x ++).

Vous pouvez plutôt faire ceci pour le même résultat:

 static int plusplus(ref int x)
{
  int xOld = x;
  x++;
  return xOld;
}

static void Main(string[] args)
{
    int x = 10;
    x = plusplus(x);
    Console.WriteLine(x);
}
 

Il convient également de mentionner que vous obtiendriez le résultat attendu de 11 si vous l’aviez fait:

 static void Main(string[] args)
{
    int x = 10;
    x = ++x;
    Console.WriteLine(x);
}
 

Answer 2

Dans la cession x = x++ vous premier extrait de l'ancienne valeur de x dans l'évaluation du côté droit de l'expression, dans ce cas, 'x'; ensuite, vous incrémentez x par 1. Enfin, vous avez affecter les résultats de l'évaluation de l'expression (10) x via l'instruction d'affectation.

Peut-être un code équivalent rendrait la situation claire:

var tmp = x;
x++;
x = tmp;

C'est l'équivalent de votre x = x++ de code en C#.

Answer 3

Le comportement de x ++ consiste à incrémenter x mais à renvoyer la valeur avant l'incrément. Son appelé un post incrément pour cette raison.

Donc x = x ++; tout simplement incrémentera x en premier, puis assignera la valeur initiale de x à x.

Answer 4

x = ++ x

serait égal à 11.

Answer 5

 x++;
 

fait ce qui suit:

 int returnValue = x;
x = x+1;
return returnValue;
 

Comme vous pouvez le constater, la valeur d'origine est enregistrée, x est incrémenté, puis la valeur d'origine est renvoyée.

Cela finit par sauvegarder la valeur 10 quelque part, en définissant x comme étant égal à 11, puis en renvoyant 10, ce qui ramène x à 10. Notez que x devient en fait 11 pendant quelques cycles (en supposant qu'aucune optimisation du compilateur ne soit effectuée) .