C++ Inkrement & Dekrement Operatoren

[F!r3f0x]

Hi,

also wie ihr sehn könnt bin ich grade dabei C++ zu lernen.
Ist eigentlich nicht so schwer wie ich es mir vorgestellt habe.

Nur werd ich vom Inkrement & Dekrement total kirre^^.
Ich versteh es einerseits andererseits irgendwie doch nicht.

Hab da nen Stück code geschrieben

	int i = 1, j = 1;
	int a, b, c, d;

	a = i++;    // a = 1, i = 2
	b = i++;    // b = 2, i = 3
	c = ++j;    // c = 2, j = 2
	d = ++j;    // d = 3, j = 3

Für a kriege ich 1
Für b kriege ich 2
Für c kriege ich 2
Für d kriege ich 3

warum aber?
Ich mein die Anweisungen sind doch gleich.
Beispielsweise a und b haben beide ein Postfix und beide "i" als Wert
Trotzdem kommt bei dem einen 1 und bei dem anderen 2 raus wie kann das sein

Wie habt ihr das gelernt habt ihr irgendeine Eselsbrücke oder sowas?
Wäre echt nett wenn ihr mir helfen würdet.

 

[moagnus]

Beispielsweise a und b haben beide ein Postfix und beide "i" als Wert

Ja, aber i wird ja weitergezählt.
Ansonsten gilt:
Präfix-Schreibweise: erhöhen/verringern und den veränderten Wert zurückgeben
Postfix-Schreibweise: Wert zurückgeben und Wert verändern
Es ist nur die Reihenfolge vertauscht.
Deine Eselsbrücke musst du dir jetzt allerdings selbst zimmern.

 

[F!r3f0x]

Achsoooooooooooo............
also so wie ich das jetzt verstehe übernimmt der bei "b" nicht mehr den Wert 1 für "i", sondern "i" hat den Wert 2, weil es um 1 erhöht wurde oder?

 

[weissbrot]

jep genau so ist das

int i = 1, j = 1;
int a, b, c, d;

a = i++;    // a = 1, i = 2
b = i++;    // b = 2, i = 3
c = ++j;    // c = 2, j = 2
d = ++j;    // d = 3, j = 3

du kannst das -- bzw ++ auch davor machen das ist das Präfix was moagnus gemeint hat.

angenommen du würdest das so machen - sinnhaftigkeit mal dahingestellt:

a = i++; //a = 1, i=2
b = --i; //a = 1, i =1

sprich steht der operator davor wird erst der ausgeführt und dann erst der wert der anderen variable übergeben.

und noch etwas ganz feines:

wenn du

a = 1;
i = 1; 
a += i; // hier wird der wert von i dem wert von a dazuaddiert und gleich wieder in a geschrieben

 

[F!r3f0x]

hmm.....ok verstehe.......
hab jetzt das ganze mal bisschen verändert nur um den effekt zu erkennen.

	a = i++;
	b = i--;  
	c = i++;
	d = i--;
	e = i++;
	f = i--;
	g = i++;

da sieht man sehr schön das "i" immer 1 dazugerechnet und 1 abgezogen wird und man dann mit der Zahl weiterarbeitet.
Im Ablauf verändert sich "i" dann wie folgt: 2, 1, 2, 1, 2

Interessante Sache.
Man könnte sich das ja auch so denken

(y = x) ++;

Zuerst wird der Wert von x an y übergeben und danach wird x um 1 inkrementiert.
Naja danke für den Tipp.
Hat mir sehr geholfen ich geh dann weiter auf experimentierkurs

 

[gruffi]

Du kannst dir Präfix- und Postfix In-/Dekrement auch einfach als Funktion mit einem Argument vorstellen. Was bei Überladung in Klassen übrigens auch ähnlich gemacht wird.

Präfix Inkrement für int würde dann zB wie folgt aussehen:

int& operator ++(int& x)
{
	x = x + 1; // bzw x += 1;
	return x;
}

Und so Postfix:

int operator ++(int& x)
{
	int tmp = x;
	x = x + 1; // bzw x += 1;
	return tmp;
}

Nicht an den konkreten Funktionssignaturen stören. In-class sieht das noch ein bisschen anders aus.

 

[F!r3f0x]

ok danke habs glaub ich mehr oder weniger verstanden
denk ma mit ein wenig Übung versteh ich das dann ganz genau

 

[moagnus]

@gruffi:
Dein Beispiel ist ein wenig verwirrend, weil die vorgegebenen Operatoren für die Grunddatentypen nicht verändert werden können.
Außerdem fehlt hier die Unterscheidung zwischen Post- und Präfix, da die Funktionssignaturen (wie du schon sagst) gleich sind. Diese Unterscheidung wird erst dadurch möglich, dass die Postfix-Variante per Sprachdefinition immer ein int-Argument mehr besitzt als die Präfix-Methode. Bei Postfix darfst du außerdem keine Referenz zurückgeben, da die Rückgabe nicht das veränderte Argument ist, sondern eine innerhalb der Operator-Funktion lokale Variable.

 

[gruffi]

Dein Beispiel ist ein wenig verwirrend, weil die vorgegebenen Operatoren für die Grunddatentypen nicht verändert werden können.
Außerdem fehlt hier die Unterscheidung zwischen Post- und Präfix, da die Funktionssignaturen (wie du schon sagst) gleich sind.

Lustig. Ich schreibe das extra noch explizit hin, damit sich keiner daran stösst. Ist es für dich einfacher das zu verstehen, wenn ich es als Pseudo Code deklariere?
Den kurzen Exkurs hättest du dir übrigens sparen können. Ich konnte zumindest keine Neuigkeiten entdecken. Zumal es teilweise auch noch falsch ist. Ich kann für Postfix Operatoren nämlich sehr wohl eine Referenz zurückgeben. Member oder static Variablen schon vergessen? Auch wenn das idR wegen lvalue-ness nicht gemacht wird oder besser nicht gemacht werden sollte.

 

[moagnus]

Ich bezog mich auf deine Codebeispiele.
Und auch, wenn du meinst, du hilfst hier einem Anfänger, indem du vereinfachst, halte ich es im Gegenteil sogar für schädlich/verwirrend, wenn du eine Referenz auf eine lokale Variable returnst.

 

[gruffi]

halte ich es im Gegenteil sogar für schädlich/verwirrend, wenn du eine Referenz auf eine lokale Variable returnst.

Ja, da stimme ich dir sogar zu. Habe es deshalb auch geändert. War so auch nicht geplant und ist wohl einfach durch C&P entstanden. Aber nochmal, das ist nicht der springende Punkt. Es ging um die Wirkungsweise der Operatoren. Also das, was im Funktionsrumpf steht. In Zukunft bitte ein kurzer Hinweis und das Thema ist gegessen, anstatt irgendwelche sinnfreien Diskussionen loszutreten.