Wat is het verschil tussen ++i en i++?

Wat is in C het verschil tussen het gebruik van ++i en i++, en wat moet worden gebruikt in het incrementele blok van een for lus?


Antwoord 1, autoriteit 100%

  • ++i verhoogt de waarde van i en retourneert vervolgens de verhoogde waarde.

     i = 1;
     j = ++i;
     (i is 2, j is 2)
    
  • i++ verhoogt de waarde van i, maar retourneert de oorspronkelijke waarde die i had voordat deze werd verhoogd.

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

Voor een for-lus werkt beide. ++i lijkt vaker voor te komen, misschien omdat dat is wat wordt gebruikt in K&R .

Volg in ieder geval de richtlijn “prefereer ++i boven i++” en je zult niet fout gaan.

Er zijn een paar opmerkingen over de efficiëntie van ++i en i++. In elke compiler die geen studentenproject is, zal er geen prestatieverschil zijn. U kunt dit verifiëren door naar de gegenereerde code te kijken, die identiek zal zijn.

De efficiëntievraag is interessant… hier is mijn poging tot een antwoord:
Is er een prestatieverschil tussen i++ en ++i in C?

Zoals @OnFreund opmerkt, is het anders voor een C++-object, aangezien operator++() is een functie en de compiler weet niet hoe hij de creatie van een tijdelijk object moet optimaliseren om de tussenwaarde te behouden.


Antwoord 2, autoriteit 17%

i++ staat bekend als Post Increment terwijl ++i Pre Increment wordt genoemd.

i++

i++ is post-increment omdat het de waarde van i met 1 verhoogt nadat de bewerking is voltooid.

Laten we het volgende voorbeeld bekijken:

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

Hier waarde van j = 1 maar i = 2. Hier wordt de waarde van i eerst toegewezen aan j en daarna wordt i verhoogd.

++i

++i is pre-increment omdat het de waarde van i met 1 verhoogt vóór de bewerking.
Dit betekent dat j = i; wordt uitgevoerd na i++.

Laten we het volgende voorbeeld bekijken:

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

Hier waarde van j = 2 maar i = 2. Hier wordt de waarde van i toegewezen aan j na de i verhoging van i.
Op dezelfde manier wordt ++i uitgevoerd vóór j=i;.

Voor uw vraag welke moet worden gebruikt in het incrementatieblok van een for-lus? is het antwoord: u kunt elke gebruiken.. maakt niet uit. Het zal uw for-lus hetzelfde nummer uitvoeren. vaak.

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

En

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

Beide lussen produceren dezelfde uitvoer. bijv. 0 1 2 3 4.

Het maakt alleen uit waar je het gebruikt.

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

In dit geval is de output 1 2 3 4 5.


Antwoord 3, autoriteit 4%

Maak je geen zorgen over de “efficiëntie” (snelheid, eigenlijk) waarvan de een sneller is. We hebben tegenwoordig compilers die voor deze dingen zorgen. Gebruik wat het meest logisch is om te gebruiken, op basis waarvan je intentie duidelijker wordt weergegeven.


Antwoord 4, autoriteit 4%

++i verhoogt de waarde en geeft deze vervolgens terug.

i++ retourneert de waarde en verhoogt deze vervolgens.

Het is een subtiel verschil.

Gebruik voor een for-lus ++i, omdat dit iets sneller is. i++ maakt een extra kopie die gewoon wordt weggegooid.


Antwoord 5, autoriteit 3%

i++: In dit scenario wordt eerst de waarde toegewezen en vervolgens wordt de waarde verhoogd.

++i: in dit scenario wordt eerst de verhoging uitgevoerd en wordt vervolgens de waarde toegekend

Hieronder staat de afbeeldingsvisualisatie en ook hier is een mooie praktische video die de hetzelfde.

voer hier de afbeeldingsbeschrijving in


Antwoord 6, autoriteit 2%

De reden dat ++i iets sneller kan zijn dan i++ is dat i++ een lokale kopie kan vereisen van de waarde van i voordat deze wordt verhoogd, terwijl ++i dat nooit doet. In sommige gevallen zullen sommige compilers het indien mogelijk weg optimaliseren… maar het is niet altijd mogelijk, en niet alle compilers doen dit.

Ik probeer niet te veel te vertrouwen op optimalisaties van compilers, dus ik zou het advies van Ryan Fox opvolgen: als ik beide kan gebruiken, gebruik ik ++i.


Antwoord 7

Ze verhogen allebei het nummer. ++i is gelijk aan i = i + 1.

i++ en ++i lijken erg op elkaar, maar zijn niet precies hetzelfde. Beide verhogen het getal, maar ++i verhoogt het getal voordat de huidige uitdrukking wordt geëvalueerd, terwijl i++ het getal verhoogt nadat de uitdrukking is geëvalueerd.

Voorbeeld:

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

Antwoord 8

Het effectieve resultaat van het gebruik van een van beide in een lus is identiek. Met andere woorden, de lus zal in beide gevallen exact hetzelfde doen.

In termen van efficiëntie kan er een nadeel zijn bij het kiezen van i++ boven ++i. In termen van de taalspecificatie zou het gebruik van de post-increment-operator een extra kopie moeten creëren van de waarde waarop de operator handelt. Dit kan een bron van extra handelingen zijn.

U moet echter rekening houden met twee hoofdproblemen met de voorgaande logica.

  1. Moderne compilers zijn geweldig. Alle goede compilers zijn slim genoeg om te beseffen dat het een integer-toename in een for-loop ziet, en het zal beide methoden optimaliseren voor dezelfde efficiënte code. Als het gebruik van post-increment in plaats van pre-increment ervoor zorgt dat uw programma langzamer draait, dan gebruikt u een vreselijke compiler.

  2. In termen van operationele tijdcomplexiteit zijn de twee methoden (zelfs als er daadwerkelijk een kopie wordt uitgevoerd) equivalent. Het aantal instructies dat binnen de lus wordt uitgevoerd, zou het aantal bewerkingen in de incrementbewerking aanzienlijk moeten domineren. Daarom zal in elke lus van aanzienlijke omvang de straf van de increment-methode enorm worden overschaduwd door de uitvoering van de luslichaam. Met andere woorden, u kunt zich veel beter zorgen maken over het optimaliseren van de code in de lus in plaats van de increment.

Naar mijn mening komt het hele probleem gewoon neer op een stijlvoorkeur. Als u denkt dat pre-increment leesbaarder is, gebruik het dan. Persoonlijk geef ik de voorkeur aan de post-incrment, maar dat komt waarschijnlijk omdat ik dit heb geleerd voordat ik iets wist over optimalisatie.

Dit is een typisch voorbeeld van voortijdige optimalisatie en problemen als deze kunnen ons afleiden van serieuze ontwerpproblemen. Het is echter nog steeds een goede vraag om te stellen, omdat er geen uniformiteit is in gebruik of consensus in ‘best practice’.


Antwoord 9

Het enige verschil is de volgorde van bewerkingen tussen de toename van de variabele en de waarde die de operator retourneert.

Deze code en zijn uitvoer verklaren het verschil:

#include<stdio.h>
int main(int argc, char* argv[])
{
  unsigned int i=0, a;
  printf("i initial value: %d; ", i);
  a = i++;
  printf("value returned by i++: %d, i after: %d\n", a, i);
  i=0;
  printf("i initial value: %d; ", i);
  a = ++i;
  printf(" value returned by ++i: %d, i after: %d\n",a, i);
}

De uitvoer is:

i initial value: 0; value returned by i++: 0, i after: 1
i initial value: 0;  value returned by ++i: 1, i after: 1

Dus in feite retourneert ++i de waarde nadat deze is verhoogd, terwijl i++ de waarde retourneert voordat deze is verhoogd. Aan het einde zal in beide gevallen de waarde van de i worden verhoogd.

Nog een voorbeeld:

#include<stdio.h>
int main ()
  int i=0;
  int a = i++*2;
  printf("i=0, i++*2=%d\n", a);
  i=0;
  a = ++i * 2;
  printf("i=0, ++i*2=%d\n", a);
  i=0;
  a = (++i) * 2;
  printf("i=0, (++i)*2=%d\n", a);
  i=0;
  a = (++i) * 2;
  printf("i=0, (++i)*2=%d\n", a);
  return 0;
}

Uitvoer:

i=0, i++*2=0
i=0, ++i*2=2
i=0, (++i)*2=2
i=0, (++i)*2=2

Vaak is er geen verschil

Verschillen zijn duidelijk wanneer de geretourneerde waarde wordt toegewezen aan een andere variabele of wanneer de verhoging wordt uitgevoerd in combinatie met andere bewerkingen waarbij de voorrang van bewerkingen wordt toegepast (i++*2 is anders dan ++i*2, maar (i++)*2 en (++i)*2 geven dezelfde waarde) in veel gevallen zijn ze onderling uitwisselbaar. Een klassiek voorbeeld is de for loop-syntaxis:

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

heeft hetzelfde effect van

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

Regel om te onthouden

Om verwarring tussen de twee operators te voorkomen, heb ik deze regel aangenomen:

Associëren de positie van de operator ++ met betrekking tot de variabele i met de volgorde van de bewerking ++ met respect voor de opdracht

Met andere woorden gezegd:

  • ++ voor i betekent dat de verhoging vóór opdracht moet worden uitgevoerd;
  • ++ na i betekent dat de verhoging na opdracht moet worden uitgevoerd:

Antwoord 10

++i (Voorvoegselbewerking): Verhoogt en wijst vervolgens de waarde toe
(bijv.): int i = 5, int b = ++i
In dit geval wordt eerst 6 toegewezen aan b en vervolgens verhoogd tot 7 enzovoort.

i++ (Postfix-bewerking): wijst de waarde toe en verhoogt deze vervolgens
(bijv.): int i = 5, int b = i++
In dit geval wordt eerst 5 toegewezen aan b en vervolgens verhoogd tot 6 enzovoort.

In het geval van for loop: i++ wordt meestal gebruikt omdat we normaal gesproken de startwaarde van i gebruiken voordat de for loop wordt verhoogd. Maar afhankelijk van uw programmalogica kan dit variëren.


Antwoord 11

++i: is pre-increment, de andere is post-increment.

i++: haalt het element op en verhoogt het vervolgens.
++i: verhoogt i en geeft vervolgens het element terug.

Voorbeeld:

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

Uitvoer:

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

Antwoord 12

i++ en ++i

Deze kleine code kan helpen om het verschil vanuit een andere hoek te visualiseren dan de reeds geposte antwoorden:

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);

Het resultaat is:

//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 

Let op de voor- en na-situaties.

for-lus

Wat betreft welke van de twee moet worden gebruikt in een incrementeel blok van een for-lus, denk ik dat we het beste een goed voorbeeld kunnen nemen om een ​​beslissing te nemen:

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);

Het resultaat is:

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

Ik weet niet hoe het met u zit, maar ik zie geen verschil in het gebruik ervan, althans niet in een for-lus.


Antwoord 13

Het volgende C-codefragment illustreert het verschil tussen de pre- en post-increment- en decrement-operators:

int  i;
int  j;

Ophogingsoperators:

i = 1;
j = ++i;    // i is now 2, j is also 2
j = i++;    // i is now 3, j is 2

Antwoord 14

Ik neem aan dat je het verschil in semantiek nu begrijpt (hoewel ik me eerlijk gezegd afvraag waarom)
mensen stellen ‘wat betekent operator X’ vragen over stapeloverloop in plaats van lezen,
je weet wel, een boek of web tutorial of zoiets.

Maar hoe dan ook, wat betreft welke te gebruiken, negeer prestatievragen, die zijn:
onwaarschijnlijk belangrijk, zelfs in C++. Dit is het principe dat u moet gebruiken bij het beslissen:
welke te gebruiken:

Zeg in code wat je bedoelt.

Als u de waarde-voor-increment in uw instructie niet nodig heeft, gebruik dan niet die vorm van de operator. Het is een klein probleem, maar tenzij je werkt met een stijlgids die er een verbiedt
versie in het voordeel van de andere helemaal (ook wel een bot-headed style guide genoemd), zou je moeten gebruiken
het formulier dat het meest precies weergeeft wat u probeert te doen.

QED, gebruik de pre-increment versie:

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

Antwoord 15

Het verschil kan worden begrepen door deze eenvoudige C++-code hieronder:

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;

Antwoord 16

Het belangrijkste verschil is

  • i++ Post(Na verhoging) en
  • ++i Pre (Vóór verhoging)

    • post if i =1 de lus wordt verhoogd zoals 1,2,3,4,n
    • pre if i =1 de lus wordt verhoogd zoals 2,3,4,5,n

Antwoord 17

Voorverhooging betekent verhoging op dezelfde regel. Post-increment betekent increment nadat de regel is uitgevoerd.

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

Als het komt met OR- en AND-operatoren, wordt het interessanter.

int m=0;
if((m == 0 || m++ == 0) && (m++ == 1)) { //false
/* in OR condition if first line is already true then compiler doesn't check the rest. It is technique of compiler 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
}

In array

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
}

In C++ post/pre-increment van pointervariabele

#include <iostream>
using namespace std;
int main() {
    int x=10;
    int* p = &x;
    std::cout<<"address = "<<p<<"\n"; //prints address of x
    std::cout<<"address = "<<p<<"\n"; //prints (address of x) + sizeof(int)
    std::cout<<"address = "<<&x<<"\n"; //prints address of x
    std::cout<<"address = "<<++&x<<"\n"; //error. reference can't re-assign because it is fixed (immutable)
}

Antwoord 18

Kort:

++i en i++ werken hetzelfde als je ze niet in een functie schrijft. Als je iets als function(i++) of function(++i) gebruikt, kun je het verschil zien.

function(++i) zegt dat i eerst met 1 moet worden verhoogd, daarna zet u deze i in de functie met nieuwe waarde.

function(i++) zegt dat eerst i in de functie moet worden geplaatst, waarna i met 1 wordt verhoogd.

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

Antwoord 19

Je kunt interne conversie daarvan zien als een meerdere uitspraken;

  • geval 1
i++;

je kunt het zien als,

i;
i = i+1;
  • geval 2
++i;

je kunt het zien als,

i = i+i;
i;

Antwoord 20

a=i++ betekent dat a de huidige i-waarde bevat
a=++i betekent dat a een verhoogde i-waarde bevat


Antwoord 21

Hier is het voorbeeld om het verschil te begrijpen

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

output: 10 12/11 11 (afhankelijk van de volgorde van evaluatie van argumenten voor de functie printf, die varieert tussen compilers en architecturen)

Uitleg:
i++->i wordt afgedrukt en wordt vervolgens verhoogd. (Print 10, maar i wordt 11)
++i->i waarde wordt verhoogd en drukt de waarde af. (Drukt 12 af, en de waarde van i ook 12)

LEAVE A REPLY

Please enter your comment!
Please enter your name here

Other episodes