Ist x += 1 effizienter als x = x + 1?

In x = x + 1 ist x zweimal beurteilt? Wenn dem so ist, bedeutet das, dass in x += 1, x wird nur einmal ausgewertet? Wie sind die beiden Ausdrücke werden ausgewertet in Bezug auf compiler Zwischencode?

Beispielsweise x++ könnte bedeuten : die Position x laden Sie den Inhalt x in ein register und erhöhe den Wert von x im Speicher.

Außerdem habe ich gelesen, dass x += 1 ist nützlich, wenn x ist nicht eine einfache variable, sondern ein Ausdruck mit einem array. Irgendwelche Ideen, warum dies der Fall ist?

  • Das klingt wie eine Menge von unbegründeten Annahmen, insbesondere der Titel. Ich sehe keinen Grund, warum sollte man effizienter sein als die anderen und ich bin mir relativ sicher, dass es nicht der Fall ist, die auf die meisten C-Compiler.
  • Ein compiler das Geld Wert, das Sie dafür bezahlt wird, kompilieren Sie beide Ausdrücke auf das gleiche Objekt-code. Wenn Sie besorgt über die Leistung: Messen, Messen, unterschiedliche Codes, unterschiedliche Zusammenstellung flags, die unterschiedliche Ressourcen-Nutzung, verschiedene alles.
  • Wissen Sie, dass x += 1 ist effizienter als x = x + 1? Haben Sie schaute auf die generierte Objekt-code?
  • Vielleicht war dies gegebenenfalls auch ältere Compiler..ich bin neugierig, warum man könnte effizienter sein, als die anderen in einem älteren compiler...ich Las darüber in einem Buch mit dem Titel "Deep C Secrets".
  • Wie über die Suche nach einigen Büchern, die nicht 17 Jahre alt?
  • Es ist denkbar, einen Unterschied in C++ (wenn x ist ein UDT), aber es sollte kein Unterschied in C.
  • Ok..also, wenn x ist ein vom Benutzer definierter Typ, wie würde x =+1 effizienter sein?
  • Fragen über UDTs ist eine andere Frage. Diese Frage ist etwa C.
  • Es ist nicht nur ein Duplikat ist; diese Frage hat eine falsche Annahme in der Betreff-Zeile.
  • Ja, das war mein Punkt...

InformationsquelleAutor user7 | 2011-09-19
  1. 12

    In den meisten Compiler diese wäre identisch

    • was ist mit dem älteren Compiler? das nicht optimieren, so viel wie die neueren..warum sind Sie unterschiedlich beurteilt?
    • Wenn der compiler ineffizient ist, kann die Tatsache ignorieren, dass die x genannt wird, zweimal, und laden Sie es und führen Sie dann die Inkrementierung der Betrieb auf dem geladenen Wert.
    • und was den Kommentar über arrays?
    • wieder ein guter compiler wird in der Lage sein zu produzieren, die den gleichen code, aber eine ineffiziente hätte man mehr Schwierigkeiten mit komplexeren Ausdrücke im Zusammenhang mit array-Mitglieder
    InformationsquelleAutor Ofir
  2. 14

    Nur, um Ihnen eine "real-world" - Beispiel, betrachten Sie dieses Programm:

    int main()
{
    int i = 0;
    i += 1;
    i++;
    i = i + 1;
    return 0;
}

    Kompilieren mit GCC in Darwin 11 mit den folgenden flags:

    • -S halt in assembler
    • -m32 zu 32-bit-Plattform, nur um die Dinge zu vereinfachen ein wenig

    Generiert das folgende Programm, außer für die Kommentare und Leerzeilen, die ich Hinzugefügt. Schauen Sie speziell in die Kommentare.

            .section        __TEXT,__text,regular,pure_instructions
        .globl  _main
        .align  4, 0x90
_main:
        pushl   %ebp              # cdecl function stuff
        movl    %esp, %ebp        #
        subl    $12, %esp         # get room for variables    
        movl    $0, -12(%ebp)     # i = 0;

        ; i += 1
        movl    -12(%ebp), %eax   # load i in register a
        addl    $1, %eax          # add 1 to register a
        movl    %eax, -12(%ebp)   # store it back in memory

        ; i++
        movl    -12(%ebp), %eax   #
        addl    $1, %eax          # just the same
        movl    %eax, -12(%ebp)   #

        ; i = i + 1
        movl    -12(%ebp), %eax   #
        addl    $1, %eax          # just the same
        movl    %eax, -12(%ebp)   #

        movl    $0, -8(%ebp)
        movl    -8(%ebp), %eax
        movl    %eax, -4(%ebp)
        movl    -4(%ebp), %eax
        addl    $12, %esp
        popl    %ebp
        ret

.subsections_via_symbols
    • Ich weiß nicht, warum dies nicht als "Antwort" gekennzeichnet, denn es liefert den Beweis und nicht nur eine Meinung.
    • Dies sollte als "Antwort" gekennzeichnet. Auch finden wir keinen Unterschied, in anderen Compilern oder hat es den gleichen mustern Folgen ?
    • Danke. Schwer zu sagen, angesichts der Menge von Compilern. Aber jeder compiler mit einer anständigen Entwicklung wird wahrscheinlich enthalten diese "Intelligenz". Compiler sind nicht nur direkte übersetzer von high-auf low-Pegel, es ist eine ganze Wissenschaft beteiligt und Beispiele wie dieses sind, gehören zu den grundlegenden und ersten Elemente dieser Wissenschaft. So einen modernen und größeren compiler sollte Sie gehören.
    InformationsquelleAutor sidyll
  3. 7

    Warum ist x += 1 effizienter als x = x+1?

    Ist es nicht.

    Warum ist x++ effizienter ist als x += 1?

    Ist es nicht.

    Den Grund für den Vorzug x += 1 zu x = x+1 kommt zustande, wenn x ersetzt mit einem viel längeren identifier, oder vielleicht ein Feld in einer Klasse oder Struktur. In dieser situation, die x += 1 version ist leichter lesbar und-noch wichtiger-vermeidet die Fallstricke wiederholen.

    InformationsquelleAutor David Heffernan
  4. 3

    Also es gibt schon einige Fragen, die cover, was Sie Fragen ist hier:

    x=x+1 gegen x +=1

    Der Inkrementierung: x++ vs x += 1

    Welche ist schneller? ++, += oder x + 1?

    Die Quintessenz ist, dass in den meisten aber nicht alle Sprachen der compiler wird Sie sowieso identisch, es gibt also keinen Unterschied in der Effizienz. Die obigen Fragen gehen in eine gerechte bisschen näher auf das Thema ein.

    InformationsquelleAutor lxt
  5. 0

    Mit gcc, können Sie den assembler-code mit gcc -S foo.c. Ich versuchte es mit x += 1 und x = x + 1 und es war das gleiche.

    InformationsquelleAutor wst
  6. 0

    Da dauert es 4 Zeichen zu schreiben, anstatt 5.

    Dies ist der einzige Weg in die x+=1 ist "effizienter" als x=x+1. Aber die += Betreiber hat ein paar andere Vorteile, wie die Tatsache, dass (x)+=1 arbeitet in Makros, wo x ist ein Ausdruck, die Nebenwirkungen haben können, die Sie wollen vermeiden, dass die Bewertung mehr als einmal...

    InformationsquelleAutor R..
Schreibe einen Kommentar