Quelle est la différence entre ++ i et i ++?

En C, quelle est la différence entre utiliser ++i et i++ , et qui devrait être utilisé dans le bloc d’incrémentation d’une boucle for ?

  • ++i vais incrémenter la valeur de i , puis retourner la valeur incrémentée.

      i = 1; j = ++i; (i is 2, j is 2) 
  • i++ incrémentera la valeur de i , mais retournera la valeur d’origine que i avant d’incrémenter.

      i = 1; j = i++; (i is 2, j is 1) 

Pour une boucle for , l’une ou l’autre fonctionne. ++i semble plus commun, peut-être parce que c’est ce qui est utilisé dans K & R.

En tout cas, suivez les instructions “prefer ++i over i++ ” et vous ne vous tromperez pas.

Il y a quelques commentaires concernant l’efficacité de ++i et i++ . Dans tout compilateur non-étudiant-projet, il n’y aura pas de différence de performance. Vous pouvez le vérifier en consultant le code généré, qui sera identique.

La question de l’efficacité est intéressante … voici ma tentative de réponse: Y a – t-il une différence de performance entre i ++ et ++ i en C?

Comme pour les notes On Freund , il en va différemment pour un object C ++, car operator++() est une fonction et le compilateur ne peut pas savoir optimiser la création d’un object temporaire pour contenir la valeur intermédiaire.

i ++ est appelé Post Increment alors que ++ i s’appelle Pre Increment.

i++

i++ est un incrément de poste car il incrémente la valeur de i après la fin de l’opération.

Voyons l’exemple suivant:

 int i = 1, j; j = i++; 

Ici valeur de j = 1 mais i = 2 . Ici, la valeur de i sera affectée à j premier, puis i serai incrémenté.

++i

++i est pré-incrémenté car il incrémente la valeur de i avant l’opération. Cela signifie j = i; s’exécutera après i++ .

Voyons l’exemple suivant:

 int i = 1, j; j = ++i; 

Ici valeur de j = 2 mais i = 2 . Ici, la valeur de i sera assignée à j après l’incrémentation de i . De même, ++i sera exécuté avant j=i; .

Pour votre question qui devrait être utilisé dans le bloc d’incrémentation d’une boucle for? La réponse est que vous pouvez utiliser n’importe laquelle. Peu importe. Il exécutera votre pour la même boucle no. des fois.

 for(i=0; i<5; i++) printf("%d ",i); 

Et

 for(i=0; i<5; ++i) printf("%d ",i); 

Les deux boucles produiront la même sortie. à savoir 0 1 2 3 4 .

Cela ne concerne que l'endroit où vous l'utilisez.

 for(i = 0; i<5;) printf("%d ",++i); 

Dans ce cas, la sortie sera 1 2 3 4 5 .

S’il vous plaît ne vous inquiétez pas de “l’efficacité” (la vitesse, vraiment) dont on est plus rapide. Nous avons des compilateurs ces jours-ci qui s’occupent de ces choses. Utilisez celui qui est logique à utiliser, sur la base duquel plus clairement votre intention.

++i incrémente la valeur, puis la retourne.

i++ renvoie la valeur, puis l’incrémente.

C’est une différence subtile.

Pour une boucle for, utilisez ++i , car elle est légèrement plus rapide. i++ créera une copie supplémentaire qui sera simplement jetée.

i ++: – Dans ce scénario, la valeur est d’abord atsortingbuée puis l’incrémentation se produit.

++ i: – Dans ce scénario, l’incrément est d’abord effectué et la valeur est atsortingbuée

Vous trouverez ci-dessous la visualisation de l’image et voici également une belle vidéo pratique ( http://www.youtube.com/watch?v=lrtcfgbUXm4 ) qui montre la même chose.

entrer la description de l'image ici

La raison pour laquelle ++i peux être légèrement plus rapide que i++ est que i++ peut exiger une copie locale de la valeur de i avant de l’incrémenter, alors que ++i ne le fait jamais. Dans certains cas, certains compilateurs l’optimiseront si possible… mais ce n’est pas toujours possible et tous les compilateurs ne le font pas.

J’essaie de ne pas trop m’appuyer sur les optimisations des compilateurs, alors je suivrais le conseil de Ryan Fox: quand je peux utiliser les deux, j’utilise ++i .

Le résultat effectif de l’utilisation de l’un ou l’autre est identique. En d’autres termes, la boucle fera exactement la même chose dans les deux cas.

En termes d’efficacité, le choix de i ++ sur ++ i pourrait entraîner une pénalité. En ce qui concerne la spécification du langage, l’utilisation de l’opérateur de post-incrémentation doit créer une copie supplémentaire de la valeur sur laquelle l’opérateur agit. Cela pourrait être une source d’opérations supplémentaires.

Cependant, vous devriez considérer deux problèmes principaux avec la logique précédente.

  1. Les compilateurs modernes sont géniaux. Tous les bons compilateurs sont assez intelligents pour se rendre compte qu’ils voient un incrément entier dans une boucle for, et ils optimiseront les deux méthodes avec le même code efficace. Si l’utilisation de la post-incrémentation par rapport au pré-incrément entraîne un temps d’exécution plus lent de votre programme, alors vous utilisez un terrible compilateur.

  2. En termes de complexité temporelle opérationnelle, les deux méthodes (même si une copie est en cours) sont équivalentes. Le nombre d’instructions en cours d’exécution à l’intérieur de la boucle devrait largement dominer le nombre d’opérations dans l’opération d’incrémentation. Par conséquent, dans toute boucle de taille significative, la pénalité de la méthode d’incrément sera largement éclipsée par l’exécution du corps de la boucle. En d’autres termes, il vaut mieux vous soucier de l’optimisation du code dans la boucle plutôt que de l’incrément.

À mon avis, le problème se résume simplement à une préférence de style. Si vous pensez que la pré-incrémentation est plus lisible, utilisez-la. Personnellement, je préfère le post-incrémentation, mais c’est probablement parce que c’était ce qui m’avait été enseigné avant de savoir quoi que ce soit sur l’optimisation.

Il s’agit d’un exemple typique d’optimisation prématurée, et des problèmes comme celui-ci risquent de nous distraire des problèmes sérieux de conception. C’est quand même une bonne question à poser, car il n’y a pas d’uniformité dans l’utilisation ou de consensus dans les “meilleures pratiques”.

Ils augmentent tous les deux le nombre. ++ i est équivalent à i = i + 1.

i ++ et ++ i sont très similaires mais pas exactement les mêmes. Les deux incrémentent le nombre, mais ++ i incrémente le nombre avant l’évaluation de l’expression en cours, tandis que i ++ incrémente le nombre après l’évaluation de l’expression.

Exemple :

 int i = 1; int x = i++; //x is 1, i is 2 int y = ++i; //y is 3, i is 3 

++ i est pré-incrémentation l’autre est post-incrémentation

i ++: récupère l’élément et l’incrémente ensuite.
++ i: incrémente i puis retourne l’élément

Exemple:

 int i = 0; printf("i: %d\n", i); printf("i++: %d\n", i++); printf("++i: %d\n", ++i); 

Sortie:

 i: 0 i++: 0 ++i: 2 

++ i (opération de préfixe): incrémente puis assigne la valeur
(par exemple): int i = 5, int b = ++ i
Dans ce cas, 6 est affecté en premier à b puis incrémenté à 7, etc.

i ++ (opération Postfix): atsortingbue puis incrémente la valeur
(par exemple): int i = 5, int b = i ++
Dans ce cas, 5 est affecté en premier à b puis incrémenté à 6, etc.

En cas de for loop: i ++ est principalement utilisé parce que, normalement, nous utilisons la valeur de départ de i avant d’incrémenter pour loop.But mais en fonction de la logique de votre programme, cela peut varier.

Je suppose que vous comprenez la différence en matière de sémantique maintenant (mais honnêtement, je me demande pourquoi les gens demandent «Qu’est-ce que l’opérateur X veut dire» plutôt que de lire, vous savez, un livre ou un didacticiel en ligne).

Mais de toute façon, en ce qui concerne celui à utiliser, ignorez les questions de performance, qui sont peu probables même en C ++. C’est le principe que vous devez utiliser pour décider lequel utiliser:

Dites ce que vous voulez dire dans le code.

Si vous n’avez pas besoin de la valeur avant l’incrément dans votre instruction, n’utilisez pas cette forme de l’opérateur. C’est un problème mineur, mais à moins que vous ne travailliez avec un guide de style qui interdit une version en faveur de l’autre (alias un guide de style), vous devriez utiliser la forme qui exprime le mieux ce que vous essayez de faire.

QED, utilisez la version de pré-incrémentation:

 for (int i = 0; i != X; ++i) ... 

La différence peut être comprise par ce simple code C ++ ci-dessous:

 int i, j, k, l; i = 1; //initialize int i with 1 j = i+1; //add 1 with i and set that as the value of j. i is still 1 k = i++; //k gets the current value of i, after that i is incremented. So here i is 2, but k is 1 l = ++i; // i is incremented first and then returned. So the value of i is 3 and so does l. cout << i << ' ' << j << ' ' << k << ' '<< l << endl; return 0; 

La principale différence est

  • i ++ Post ( après incrément ) et
  • ++ i pré ( avant incrément )

    • post si i =1 la boucle s’incrémente comme 1,2,3,4,n
    • pre si i =1 la boucle s’incrémente comme 2,3,4,5,n

En bref: ++ i et i ++ fonctionnent de la même manière si vous ne les écrivez pas dans une fonction. Si vous utilisez quelque chose comme function (i ++) ou function (++ i), vous pouvez voir la différence.

la fonction (++ i) dit le premier incrément de i par 1, après cela, mettez ceci i dans la fonction avec une nouvelle valeur.

La fonction (i ++) indique que je mets d’abord i dans la fonction après cet incrément i de 1.

 int i=4; printf("%d\n",pow(++i,2));//it prints 25 and i is 5 now i=4; printf("%d",pow(i++,2));//it prints 16 i is 5 now 

Pre-crement signifie incrémenter sur la même ligne. Post-incrémentation signifie une augmentation après l’exécution de la ligne.

 int j=0; System.out.println(j); //0 System.out.println(j++); //0. post-increment. It means after this line executes j increments. int k=0; System.out.println(k); //0 System.out.println(++k); //1. pre increment. It means it increments first and then the line executes 

Quand il vient avec les opérateurs OR, ET, cela devient plus intéressant.

 int m=0; if((m == 0 || m++ == 0) && (m++ == 1)) { //false /* in OR condition if first line is already true then comstackr doesn't check the rest. It is technique of comstackr optimization */ System.out.println("post-increment "+m); } int n=0; if((n == 0 || n++ == 0) && (++n == 1)) { //true System.out.println("pre-increment "+n); //1 } 

Dans le tableau

  System.out.println("In Array"); int[] a = { 55, 11, 15, 20, 25 } ; int ii, jj, kk = 1, mm; ii = ++a[1]; // ii = 12. a[1] = a[1] + 1 System.out.println(a[1]); //12 jj = a[1]++; //12 System.out.println(a[1]); //a[1] = 13 mm = a[1];//13 System.out.printf ( "\n%d %d %d\n", ii, jj, mm ) ; //12, 12, 13 for (int val: a) { System.out.print(" " +val); //55, 13, 15, 20, 25 } 

En C ++ post / pre-incrément de variable de pointeur

 #include  using namespace std; int main() { int x=10; int* p = &x; std::cout<<"address = "< 

Le fragment de code C suivant illustre la différence entre les opérateurs pré et post-incrémentation et décrémentation:

int i int j;

// Incrémenter les opérateurs

i = 1;

j = ++ i; // je suis maintenant 2, j est aussi 2

j = i ++; // je suis maintenant 3, j est 2

i ++ et ++ i

Ce petit code peut aider à visualiser la différence sous un angle différent des réponses déjà affichées:

 int i = 10, j = 10; printf ("i is %i \n", i); printf ("i++ is %i \n", i++); printf ("i is %i \n\n", i); printf ("j is %i \n", j); printf ("++j is %i \n", ++j); printf ("j is %i \n", j); 

Le résultat est le suivant:

 //Remember that the values are i = 10, and j = 10 i is 10 i++ is 10 //Assigns (print out), then increments i is 11 j is 10 ++j is 11 //Increments, then assigns (print out) j is 11 

Faites attention aux situations avant et après.

pour la boucle

Quant à savoir lequel d’entre eux devrait être utilisé dans un bloc d’incrémentation d’une boucle for, je pense que le mieux que nous puissions faire pour prendre une décision est d’utiliser un bon exemple:

 int i, j; For (i = 0; i <= 3; i++) printf (" > iteration #%i", i); printf ("\n"); for (j = 0; j <= 3; ++j) printf (" > iteration #%i", j); 

Le résultat est le suivant:

 > iteration #0 > iteration #1 > iteration #2 > iteration #3 > iteration #0 > iteration #1 > iteration #2 > iteration #3 

Je ne sais pas pour vous, mais je ne vois aucune différence dans son utilisation, du moins dans une boucle for.

Vous pouvez penser à la conversion interne de cette déclaration en plusieurs déclarations ;

 // case 1 : i++; /* you can think as, * i; * i= i+1; */ // case 2 ++i; /* you can think as, * i = i+i; * i; */ 

a = i ++ signifie que contient une valeur i courante a = ++ i signifie une valeur incrémentée de contient

Voici l’exemple pour comprendre la différence

 int i=10; printf("%d %d",i++,++i); 

output: 10 12/11 11 (en fonction de l’ordre d’évaluation des arguments de la fonction printf , qui varie selon les compilateurs et les architectures)

Explication: i++ -> i est imprimé, puis s’incrémente. (Imprime 10, mais i deviendrai 11) ++i -> i incrémente et imprime la valeur. (Imprime 12 et la valeur de i aussi 12)