5. x++ und ++x?

x++ und ++x?

  • K

    Ich beschäftige mich schon seit Stunden mit der Frage, was der Unterschied zwischen

    blah(blubb-blahblah-1);
blubb--;
blahblah--;

    und

    blah(--blubb-blahblah--);

    und

    blah((--blubb)-(blah--));

    ist. Ich kapier das irgendwie nicht. Ich weiß nur, dass mein Programm sich, je nachdem, wie ich das schreibe, unterschiedlich verhält.

    Blah,
    Krecik

    [edit Shade]
    'besserer' Titel fuers FAQ
    [/edit]

    [ 10.10.2001: Beitrag editiert von: Shade Of Mine ]

    0
  • M

    also das erste bespiel kann ich dir erklären :

    blah--;

    da wird blah um -1 inkrementiert

    blah--; ist das selbe wie blah=blah-1;

    geht auch mit + , c++; ist das selbe wie c=c+1; images/smiles/icon_biggrin.gif
    und falls du das noch nicht gesehn hast c+=10; ist das selbe wie c=c+10; oder c*=10; ist das selbe wie c=c*10;

    also die 2 letzten bespiele von dir ahb ich auch noch net gesehn images/smiles/icon_rolleyes.gif

    0
  • ?

    Das letzte gibt 'nen Error!
    Gut, ich nehme mal an, es soll blahblah in der Klammer heißen.
    Es gibt einfach einen Unterschied zwischen Präin/decrement und
    Postin/decrement.

    Um's in Zahlen zu zeigen:
    blubb=7 blahblah=4

    1.) blah(7-4-1); ausgeführt wird blah(2)
    blubb--; blubb wird 6
    blahblah--; blah wird 3

    2.) blah(--blubb-blahblah--);
    blah((--7) - (4--));
    blubb wird predecrementiert, d.h, das Decrement wird VOR einer
    anderen Berechnung ausgeführt.
    blahblah wird postdecrementiert, d.h., das Decrement wird NACH
    der anderen Berechnung ausgeführt.
    ABER: würde Du b global nehmen und nun in blah printen, so ist
    es zu diesem Zeitpunkt doch schon eins weniger!
    Praktisch sieht es so aus, daß der Inhalt von blahblah für die
    nächste Operation gelesen wird, und blahblah dann decrementiert
    wird.
    Die Folge:

    blubb--;
    blah(blubb-blahblah);
    blahblah--;

    bringt also nur gleiche Resultate, wenn blah nicht direkt auf
    blahblah zugreift.

    Effektiv wird gerufen:
    blah(6-4);
    danach sind blubb 6 und blah 3.

    3.) identisch zu 2.

    Nochmal zur Situation in blah()

    1.) blubb=7 blahblah=4
    2.+3.) blubb=6 blahblah=4

    Nach Ausführung der Befehle gilt in allen Fällen:
    blubb=6 blahblah=3

    Blubb!

    0
  • B

    Mal was zum Nachdenken:

    sind die beiden Ausdrücke

    --x und (x-- - 1)
    (oder auch x-- und (--x + 1))

    semantisch äquivalent?

    0
  • V

    Original erstellt von Bashar:
    **Mal was zum Nachdenken:

    sind die beiden Ausdrücke

    --x und (x-- - 1)
    (oder auch x-- und (--x + 1))

    semantisch äquivalent?**

    Ich teste mal, ob --x=x---x mit der anderen Version das gleiche Ergebnis bringt. Wenn ich mal die Compilerfehler wegkriege.

    0
  • ?

    @Bashar:
    Solange nichts überladen ist, würde ich in rvalue-Situationen spontan mal ja behaupten. Bei --x wird x decrementiert und dann in den
    Akku geholt. Bei x-- wird x in den Akku geholt und dann direkt decrementiert. Nun folgt wg. - 1 noch die Decrementierung des Akkus.
    Möglicherweise optimiert der Compiler diese erkennbare Situation.
    Ein Timerinterrupt der x verwendet könnte ruhig reinhauen, weil er mit dem Akku nichts am Hut hat. An den Limits machts auch nichts aus (selbst wenn x unsigned ist).

    0
  • ?

    jo, glaub ich auch. und mein Compilerfehler hat irgendwas mit lvalues zu tun.

    0
  • K

    Ich würde micht versuhcen demn Ausdruck --x einen WErt zuzuweisen images/smiles/icon_biggrin.gif

    0
  • S

    --x == x-- -1;

    ich wuerde sagen nein images/smiles/icon_wink.gif

    denn das ist ja die kurzschreibweise fuer

    x=x-1;
    x==x-1;
    x=x-1;

    und x ist definitive ungleich x-1

    allerdings wuerde ich sagen dass sie semantisch aequvalent sind images/smiles/icon_smile.gif
    beispiel:

    --x==y;

    lange form:
    x=x-1;
    x==y

    x-- -1==y;

    lange form:
    x-1==y
    x=x-1;

    bei beiden variante wird das um 1 verringerte x mit y verglichen und danach hat x den wert von x-1...

    also semantisch gleich...

    0
  • M

    hier noch mal was von mir images/smiles/icon_wink.gif

    also wenn da steht :

    a=b++;

    dann wird a zuerst der wert von b zu gewiesen und b wird dann um eins inkremitiert
    schreibt man aber

    a=++b;

    wird b zuerst um 1 inkrementiert und dann wird a der wert von b zu gewiesen images/smiles/icon_smile.gif

    doppelt gemoppelt gehts aber net images/smiles/icon_wink.gif

    also a=++b++; geht net !!

    also ich denk jetzt dürften auch die 2 letzen beispiele mit ein wenig logischen denken gemeistert werden images/smiles/icon_wink.gif

    0
  • V

    Original erstellt von Kauz01:
    Ich würde micht versuhcen demn Ausdruck --x einen WErt zuzuweisen images/smiles/icon_biggrin.gif

    Warum?
    --x ist doch ein lvalue.
    --x-- geht deshalb nicht, weil rechte Operatoren meistens vor linken ausgewertet werden.
    --(x--) geht also net.
    Bei (--x)-- seh ich kein Problem.

    0
  • V

    Original erstellt von Shade Of Mine:
    **--x == x-- -1;
    ich wuerde sagen nein images/smiles/icon_wink.gif
    **

    Ich auch.
    Ich wollte ja nur
    --x == x-- -1;
    compilieren und dann schauen, ob ich --x durch (x-- - 1)
    ersetzen kann und es kommt das gleiche raus.

    0
  • S

    dann sind wir ja der selben meinung, volkard images/smiles/icon_wink.gif

    0
  • K

    @virtual volkard

    Weißt du ob bei "--x == x-- -1;" die Evaluationsreiehnfolge festgelegt ist?
    Ob --x das gleiche wie x-- -1 ist kriegst du auf diese Art aber nicht raus!
    Bsp.:

    int x = 2;
    --x == x-- - 1;
    // Hier ist x sicher == 0

    0
  • M

    also wenn x 2 ist dann ist --x =1 !! weil das das selbe ist wie x-- !!

    nur wenn das -- vor x steht wird sie als erstes aus gewertet ! wenn -- nach x steht wirds erst als letztes ausgewertet!

    int a=10;
    int b;

    b=a++;
    hier ist a 11 und b 10 weil b erst der wert von a zugewiesen wird und dann wird a inkrementiert !

    bei b=++a;

    wird erst a inkrementiert und dann wird der wert von dem dann inkrementierten a b zugewiesen !!! alost ist a 11 und b 11 !!

    deshalb ist --x != x-- -1 !!

    [ 10.10.2001: Beitrag editiert von: mauerranger ]

    0
  • K

    Nochmal ein kleiner Beitrag

    int a1,b1,a2,b2;
    a1 = b1 = 2;

    a2 = a1-- - 1; // a2 == 1
    b2 = --b1; // b2 == 1

    Soweit gut?

    a1-- - 1 == --b1 hat also den Wert true.

    Aber

    (--x == x-- -1 ) hat sicher den Wert false!

    Begründung:
    Eine Seite wird als erstes evaluiert. Soweit ich weiß ist hier keine Reihenfolge festgelegt. Damit wird der Wert von x verändert! Dann wird die zweite Seite evaluiert und der Wert von x nochmals verändert. Nach dem Statement ist also der Wert von x um 2 gesunken.
    Weiter hat der als erstes ausgewertete Ausdruck einen Wert, der um 1 größer ist, als der zuletzt ausgewertete Ausdruck.

    Einwände werden entgegengenommen. images/smiles/icon_smile.gif

    0
  • S

    @kauz
    genau dass haben doch volkard und ich schon festgestellt images/smiles/icon_wink.gif

    @mauerranger
    ja, wir kennen die pre- und post incerement/decrement operatoren images/smiles/icon_wink.gif

    0
Anmelden zum Antworten