Prä- und Postfix falsch??

Postfix- und Prefix-Operatoren haben zwar den gleichen Seiteneffekt, nämlich dass der Inhalt der Variablen um 1 erhöht/vermindert wird, jedoch verhalten sie sich unterschiedlich. Postfix gibt den aktuellen Wert zurück und Prefix den um 1 erhöhten/verminderten Wert. Du kannst es dir in etwa so vorstellen:

int operator_postfix(int& ref)
{
	int tmp = ref;
	ref = ref+1; // analog zu Minus.
	return tmp;
}

int& operator_prefix(int& ref)
{
	ref = ref+1; // analog zu Minus.
	return ref;
}

silent_max

Wie macht ihr das, dass der Quellcode in Farbe ist?

Wie schon geschrieben, ich habe

> den Quellcode kopiert
> auf das C/C++ Kästchen geklickt
> und den Quellcode eingefügt.

Habe ich was falsch gemacht?

silent_max schrieb:

Habe ich was falsch gemacht?

Scheint so. Du markierst deinen gesamten Quellcode und klickst dann 1x auf das C/C++ Kästchen.

silent_max

Ja ok.

Dann erst einfügen, dann markieren und dann auf das Kästchen klicken.

Gut ... kapiert.

Und danke für die schnellen Antworten. Hat mich echt weiter gebracht...

silent_max

So, ich versuch es auf ein neues.

Quellcode kopiert, dann eingefügt und markiert und zuletzt auf C/C++ Kästchen geklickt

[/cpp]#include <iostream>
using namespace std;

int main()
{
int mein_Alter = 30;
int dein_Alter = 30;

cout << "Ich bin " << mein_Alter << " Jahre alt!" << endl;
cout << "Du bist " << dein_Alter << " Jahre alt!" << endl;
cout << endl;
cout << "Ein Jahr vergangen!" << endl;
cout << endl;
cout << "Ich bin " << ++mein_Alter << " Jahre alt!" << endl;
cout << "Du bist " << ++dein_Alter << " Jahre alt!" << endl;
cout << endl;
cout << "Ein weiteres Jahr vergangen!" << endl;
cout << endl;
cout << "Ich bin " << ++mein_Alter << " Jahre alt!" << endl;
cout << "Du bist " << ++dein_Alter << " Jahre alt!" << endl;
cout << endl;
return 0;
}
[cpp]

Da ist irgendwo der Hund drin. Klick einfach mal auf zitieren eines Beitrags, in dem es Quellcode gibt (z.B. meiner oben), dann siehst du, dass der Quellcode in [ cpp] und [ /cpp] eingerahmt ist.

silent_max

#include <iostream>
using namespace std;

int main()
{
	int mein_Alter = 30;
	int dein_Alter = 30;

	cout << "Ich bin " << mein_Alter << " Jahre alt!" << endl;
	cout << "Du bist " << dein_Alter << " Jahre alt!" << endl;
	cout << endl;
	cout << "Ein Jahr vergangen!" << endl;
	cout << endl;
	cout << "Ich bin " << ++mein_Alter << " Jahre alt!" << endl;
	cout << "Du bist " << ++dein_Alter << " Jahre alt!" << endl;
	cout << endl;
	cout << "Ein weiteres Jahr vergangen!" << endl;
	cout << endl;
	cout << "Ich bin " << ++mein_Alter << " Jahre alt!" << endl;
	cout << "Du bist " << ++dein_Alter << " Jahre alt!" << endl;
	cout << endl;
	return 0;
}

Es ist so verständlich ... erst

und dann

...

Jetzt hamas

Jetzt nur eine Verständnisfrage... es ist doch aus Gründen der Übersicht generell besser den Präfix-Operator zu verwenden? Zumindest, so empfinde ich es, ist es doch verständlicher, kürzer und übersichtlicher, den Präfix-Operator zu verwenden

vario-500

es ist nicht nur kürzer uns übersichtlicher, es wird auch eine temporäre variable gespart, wenn die nicht eh weg optimiert wird

Thuruk

Leider wird Anfängern immer erst der Postfixoperator beigebracht - steht dann völlig unnötig in allen for-Schleifen.

Dort, wo es keinen logischen Unterschied macht, sieht man es in C++ allgemein als gute Angewohnheit an, Präinkrement und -dekrement vorzuziehen. Das liegt vor allem daran, dass bei der Überladung dieser Operatoren (etwa für Iterator-Typen) eine Kopie gespart wird - eine typische Implementation könnte so aussehen:

class my_iterator {
...

  // Präinkrement; Referenzrückgabe
  my_iterator &operator++()    { 
    increment();
    return *this;
  }

  // Postinkrement; Kopierückgabe
  my_iterator  operator++(int) {
    my_iterator old_value(*this); // Extraarbeit!

    increment();

    return old_value;
  }
};

Für Basistypen ist hier allerdings kein Unterschied zu erwarten; diese werden in aller Regel komplett in Registern verarbeitet, und ob jetzt erst erhöht und dann in den Speicher geschoben wird oder umgekehrt dürfte keinen großen Unterschied machen (zumal ein optimierender Compiler das eh intelligent behandeln dürfte).

Dort, wo es einen logischen Unterschied macht, ist der Vergleich einer zwischen Äpfeln und Birnen. Ich würde allerdings anmerken, dass man Situationen, in denen es einen Unterschied macht, meistens vermeiden sollte, weil es sehr leicht ist, sich damit undefiniertes Verhalten bzw. unspezifizierte Werte einzuhandeln. Etwa ist die Ausgabe von

int i = 0;

std::cout << i++ << i++;

durch den Standard nicht spezifiziert. Stichwort für Google: Sequence points.