Différence entre i ++ et ++ j’ai dans une boucle ?

Question

Y a-t-il une différence dans et dans un `` boucle ? Est-ce simplement une chose de syntaxe ?

Answer 1

a++ est connu comme postfix.

ajouter 1 à un, retourne l'ancienne valeur.

++un est connu comme préfixe.

ajouter 1 à un, renvoie la nouvelle valeur.

C#:

string[] items = {"a","b","c","d"};
int i = 0;
foreach (string item in items)
{
    Console.WriteLine(++i);
}
Console.WriteLine("");

i = 0;
foreach (string item in items)
{
    Console.WriteLine(i++);
}

Sortie:

1
2
3
4

0
1
2
3

foreach et while boucles dépendent du type d'incrément que vous utilisez. Avec des boucles comme ci-dessous cela ne fait aucune différence que vous n'utilisez pas la valeur de retour de i:

for (int i = 0; i < 5; i++) { Console.Write(i);}
Console.WriteLine("");
for (int i = 0; i < 5; ++i) { Console.Write(i); }

0 1 2 3 4
0 1 2 3 4

Si vous utilisez la valeur comme ci-dessous puis bien évidemment, il sera important qui type d'incrément est utilisé:

int n = 0;
for (int i = 0; i < 5;n = i++) { }

Answer 2

Pré-incrémentation ++j' incrémente la valeur de i et renvoie la nouvelle valeur incrémentée.

int i = 3;
int preIncrementResult = ++i;
Assert( preIncrementResult == 4 );
Assert( i == 4 );

La Post-incrémentation i++ incrémente la valeur de i et évalue la non-valeur incrémentée.

int i = 3;
int postIncrementResult = i++;
Assert( postIncrementtResult == 3 );
Assert( i == 4 );

---

En C++, la pré-incrémentation est généralement préférée où vous pouvez utiliser.

Ce est parce que si vous utilisez la post-incrémentation, il peut exiger que le compilateur pour générer du code qui crée un supplément variable temporaire. C'est parce que à la fois les anciennes et les nouvelles valeurs de la variable qui est incrémenté à quelque part, car ils peuvent être utilisés ailleurs dans l'expression à évaluer.

Donc, en C++, au moins, il peut y avoir une différence de performance qui guide le choix de l'utiliser.

C'est principalement un problème uniquement lorsque la variable incrémentée est un type défini par l'utilisateur avec un substituée ++ opérateur. Pour les types primitifs (int, etc) il n'y a pas de différence de performances. Mais, il vaut la peine de coller à la pré-incrémentation de l'opérateur comme une directive, à moins que la post-incrémentation de l'opérateur est certainement ce qui est nécessaire.

Il y a un peu plus de discussion ici:
http://en.allexperts.com/q/C-1040/Increment-operators.htm

En C++, si vous utilisez STL, vous pouvez être en utilisant des boucles avec des itérateurs. Ces principalement l'avez remplacé ++ opérateurs, afin de coller à la pré-incrémentation est une bonne idée. Les compilateurs d'obtenir plus intelligent de tous les temps, et de nouveaux peuvent être en mesure de procéder à des optimisations qui signifie il n'y a pas de différence de performances, surtout si le type est incrémenté est défini en ligne dans le fichier d'en-tête (STL implémentations sont souvent) pour que le compilateur puisse voir comment la méthode est mise en œuvre et peut alors savoir ce que les optimisations sont sans danger à accomplir. Même ainsi, il est probablement encore la peine de coller à la pré-incrémentation, car les boucles sont exécutées beaucoup de temps et cela signifie une petite perte de performance pourrait bientôt obtenir amplifié.

---

Dans d'autres langages tels que C#, où l' ++ opérateur ne peut pas être surchargé il n'y a pas de différence de performances. Utilisée dans une boucle à l'avance la variable de boucle, le pré-et post-incrémentation opérateurs sont équivalentes.

Correction: la surcharge ++ en C# est autorisé. Il semble bien que, que, par rapport à c++, c# vous ne pouvez pas surcharger le pré et post versions indépendamment. Donc, je suppose que si le résultat de l'appel d' ++ en C# n'est pas affecté à une variable ou d'une partie d'une expression complexe, alors le compilateur permettrait de réduire le pré et post versions de ++ vers le bas pour le code qui effectue de manière équivalente.

Answer 3

En c#, il n’y a aucune différence lorsqu’il est utilisé dans une boucle for.

sorties la même chose que

Comme d’autres l’ont fait sortir, lorsqu’il est utilisé en général i ++ et ++ j’ai une différence subtile mais importante :

i ++ lit la valeur d’i puis il incrémente.

++ J’incrémente la valeur d’i, puis le lit.

Answer 4

Depuis que vous vous posez sur la différence dans une boucle, je suppose que tu veux dire

for(int i=0; i<10; i++) 
    ...;

Dans ce cas, vous n'avez pas de différence dans la plupart des langues: La boucle se comporte de la même, peu importe si vous écrivez i++ et ++i. En C++, vous pouvez écrire vos propres versions de l' ++ opérateurs, et vous pouvez définir distincts sens pour eux, si l' i est d'un type défini par l'utilisateur (votre propre classe, par exemple).

La raison pour laquelle il n'a pas d'importance parce que vous n'utilisez pas la valeur de i++. Une autre chose, c'est quand vous ne

for(int i=0, a = 0; i<10; a = i++) 
    ...;

Maintenant, il est une différence, parce que, comme d'autres font remarquer, i++ moyens d'incrémentation, mais d'évaluer à la valeur précédente, mais ++i moyens d'incrémentation, mais d'évaluer à l' i (il peut donc s'évaluer à la valeur à neuf). Dans le cas ci-dessus, a est affectée à la valeur précédente de i, alors i est incrémenté.

Answer 5

Comme ce code montre (voir le dissambled MSIL dans les commentaires), le compilateur c# 3 ne fait aucune distinction entre i ++ et ++ i dans une boucle for. Si la valeur de i ++ ou ++ je devais être pris, il y aurait certainement une différence (Ceci a été compilé en boîte Studio 2008 / Release Build) :