Inkrementoperator ++

Firefighter

Lies dir mal den Beitrag von drakon durch, da wirds erklärt
http://www.c-plusplus.net/forum/viewtopic-var-t-is-229165-and-highlight-is-prefix.html

Hallo,

Wenn der Inkrementoperator alleine steht wie z.B in einer for-Schleife ist ++i und i++ exakt das gleiche..

Aber in einer zuweißung gibt es da einen kleinen Unterschied,

Wenn du schreibst:

int var = i++;

wir var zuerst i zugewießen und dann i um 1 erhöht. ( var erhält also den wert von i)

int var = ++i;

Hier wird i um 1 erhöht und dann var zugewießen.

Eric Cartman

Also ich glaube ich verstehs jetzt allmaehlich...

das "i++" entfaltet seine Wirkung in jedem Falle erst NACH dem ersten Schleifendurchgang...

Aber ich haette jetzt da doch noch eine Frage...

Wenn ich z.B. einen Vergleich mache

if(a==++i)

wird i jetzt inkrementiert oder nur ueberpruft ob a um eins groesser ist als i und i NICHT inkrementiert?
Und wie siehts umgekehrt aus? (if(a==i++)) Wird da ueberprueft, ob a gleich i ist und i danach um 1 inkrementiert oder wie oben?

asc

Eric Cartman schrieb:

Wenn ich z.B. einen Vergleich mache
if(a==++i)
wird i jetzt inkrementiert oder nur ueberpruft ob a um eins groesser ist als i und i NICHT inkrementiert?

Der Inkrementoperator inkrementiert. Sprich i ist um eins größer. Unabhängig ob du die Prekrement- (++i) oder Postkrementvariante (i++) wählst.

und:

int i = 1
if(a==++i)... // Vergleich gegen 2, i=2

i = 1
if(a==i++)... // Vergleich gegen 1, i=2

cu André

Softwaremaker

int  x = 5;
int y;

// 1. Variante
y = ++x;
// y ist jetzt 6, denn x wird um 1 erhöht und dann wird der Inhalt von x dem y zugewiesen, x ist auch 6

// 2. Variante
int  x = 5;
int y;

y = x++;
// y ist jetzt 5, x ist 6
//x wird um 1 erhöht aber der alte Wert von x wird dem y zugewiesen

//Beim Vergleich
if(a==++i)
i wird zuerst um 1 erhöht, dieser Wert wird dann mit a verglichen (==)

if(a==i++)
i wird zuerst um 1 erhöht, aber der vorherige Wert wird mit a verglichen (==)

Softwaremaker

wert&   wert::operator++()
{
    *this = *this + 1;
    return *this;
}

wert   wert::operator++(int)
{
    wert    oldwert =*this; // alten Stand sichern
    *this = *this + 1;      // Variable erhöhen
    return oldwert;        // aber return alten Stand
}

drakon

@ Softwaremaker
Wie wäre es, wenn du ebenfalls Tags benutzen würdest?

Eric Cartman

Habs jetzt verstanden, danke fuer eure Hilfe!

Tatsaechlich wuerde nur folgende Anweisung i unveraenderlich lassen:

if(a==i+1)

Ich versteh jetzt nur den Sinn des Inkrementieroperators nicht... vielleicht ist das auch vorerst gar nicht wichtig.

Und jetzt versteh ich nicht, fuer was "size_t" eigentlich gut ist. Im Buch steht er sei ein "vorzeichenloser Zahlenttyp fuer das Ergebnis von sizeof()" oder sowas. Kann man da nicht einfach unsigned nehmen?

Gruss,
Cartman

edit: Tippfehler ausgebessert

++ als Abkürzung und um komplexe Ausdrücke zu ermöglichen. Zu faul für ein Beispiel jetzt. Überleg halt mal.

size_t is bei mir unsigned int... vergiss size_t

Eric Cartman

Google Fan schrieb:

++ als Abkürzung und um komplexe Ausdrücke zu ermöglichen. Zu faul für ein Beispiel jetzt. Überleg halt mal.

size_t is bei mir unsigned int... vergiss size_t

Ganz schoen verwirrend Danke fuer deine Antwort

Gruss,
Cartman

asc

Der Inkrementoperator ist als das Erhöhen um eine Position definiert, und auch bei den Iteratoren in Verwendung. Und die Addieren nicht 1.

Es ist halt eine, unter anderem in C++, gebräuchliche Kurzschreibweise (Sei es nun für for-Schleifen, oder das durchiterieren von Containern).

Google Fan schrieb:

size_t is bei mir unsigned int... vergiss size_t

Schlechter Ansatz, sehr schlechter Ansatz. size_t kann anders als unsigned int definiert sein, daher würde ich solche unqualifizierten Aussagen lassen.

Nexus

Eric Cartman schrieb:

das "i++" entfaltet seine Wirkung in jedem Falle erst NACH dem ersten Schleifendurchgang...

Sowie alle Aktualisierungsanweisungen im Schleifenkopf erst nach dem ersten Durchgang ausgeführt werden. Das liegt nicht am i++ , dasselbe gilt beispielsweise für ++i .