Wat is het verschil tussen i++ & ++i in een for-lus?

Ik ben net begonnen met het leren van Java en ben nu bezig met for loop-statements. Ik begrijp niet hoe ++i en i++ in een for-loop werken.

Hoe werken ze bij wiskundige bewerkingen zoals optellen en aftrekken?


Antwoord 1, autoriteit 100%

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.

int i = 3;
int a = i++; // a = 3, i = 4
int b = ++a; // b = 4, a = 4

Antwoord 2, autoriteit 80%

Hier is een voorbeeldles:

public class Increment
{
    public static void main(String [] args)
    {
        for (int i = 0; i < args.length; ++i)
        {
            System.out.println(args[i]);
        }
    }
}

Als ik deze klasse demonteer met javap.exe, krijg ik dit:

Compiled from "Increment.java"
public class Increment extends java.lang.Object{
public Increment();
  Code:
   0:   aload_0
   1:   invokespecial   #1; //Method java/lang/Object."<init>":()V
   4:   return
public static void main(java.lang.String[]);
  Code:
   0:   iconst_0
   1:   istore_1
   2:   iload_1
   3:   aload_0
   4:   arraylength
   5:   if_icmpge       23
   8:   getstatic       #2; //Field java/lang/System.out:Ljava/io/PrintStream;
   11:  aload_0
   12:  iload_1
   13:  aaload
   14:  invokevirtual   #3; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
   17:  iinc    1, 1
   20:  goto    2
   23:  return
}

Als ik de lus verander zodat deze i++ gebruikt en weer uit elkaar haal, krijg ik dit:

Compiled from "Increment.java"
public class Increment extends java.lang.Object{
public Increment();
  Code:
   0:   aload_0
   1:   invokespecial   #1; //Method java/lang/Object."<init>":()V
   4:   return
public static void main(java.lang.String[]);
  Code:
   0:   iconst_0
   1:   istore_1
   2:   iload_1
   3:   aload_0
   4:   arraylength
   5:   if_icmpge       23
   8:   getstatic       #2; //Field java/lang/System.out:Ljava/io/PrintStream;
   11:  aload_0
   12:  iload_1
   13:  aaload
   14:  invokevirtual   #3; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
   17:  iinc    1, 1
   20:  goto    2
   23:  return
}

Als ik de twee vergelijk, vertelt TextPad me dat de twee identiek zijn.

Wat dit zegt is dat vanuit het oogpunt van de gegenereerde bytecode er geen verschil is in een lus. In andere contexten is er een verschil tussen ++i en i++, maar niet voor loops.


Antwoord 3, autoriteit 38%

Beide verhogen de variabele i met één. Het is alsof je i = i + 1 zegt. Het verschil is subtiel. Als je het in een dergelijke lus gebruikt, is er geen verschil:

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

Als je het verschil wilt weten, bekijk dan dit voorbeeld:

int a = 0;
int b = a++; // b = 0; a = 1
a = 0;
b = ++a: // b = 1; a = 1

Het idee is dat ++a a verhoogt en die waarde retourneert, terwijl a++ de waarde van a retourneert en vervolgens a.


Antwoord 4, autoriteit 13%

De manier waarop de lus wordt verwerkt is als volgt

1 Eerst wordt de initialisatie uitgevoerd (i=0)

2 de controle wordt uitgevoerd (i < n)

3 de code in de lus wordt uitgevoerd.

4 de waarde wordt verhoogd

5 Herhaal stap 2 – 4

Dit is de reden waarom er geen verschil is tussen i++ en ++i in de for-lus die is gebruikt.


Antwoord 5, autoriteit 9%

Het verschil is dat de post-increment-operator i++ i retourneert zoals het was vóór de incrementering, en de pre-increment-operator ++i geeft i terug zoals het is na verhoging. Als je vraagt ​​naar een typische for-lus:

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

of

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

Ze zijn precies hetzelfde, aangezien je i++ of ++i niet gebruikt als onderdeel van een grotere uitdrukking.


Antwoord 6, autoriteit 5%

Zowel i++ als ++i zijn afkortingen voor i = i + 1.

Naast het wijzigen van de waarde van i, retourneren ze ook de waarde van i, ofwel vóór het toevoegen van een (i++) of na het toevoegen van een (++i) .

In een lus is de derde component een stuk code dat na elke iteratie wordt uitgevoerd.

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

De waarde van dat deel wordt niet gebruikt, dus het bovenstaande is hetzelfde als

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

of

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

Waar het een verschil maakt (tussen i++ en ++i ) is in deze gevallen

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

Antwoord 7

JLS 14.14.1, De basis voor Statement maakt duidelijk dat de ForUpdate-uitdrukking(en) worden geëvalueerd en de waarde(n) weggegooid. Het effect is dat de twee vormen identiek worden in de context van een for-instructie.

LEAVE A REPLY

Please enter your comment!
Please enter your name here

Other episodes