Postfix-Operator-Überladungsreihenfolge

Question

Mögliches Duplikat:
Undefiniertes Verhalten und Sequenzpunkte

Ich habe Schwierigkeiten, die Reihenfolge der Aktionen zu verstehen, wenn ich den Postfix-Operator überlade. Schauen wir uns die beiden kleinen Beispiele unten an:

int i = 0;
std::cout << std::endl << "i: " << i;
i = ++i;
std::cout << std::endl << "i: " << i;
i = i++;
std::cout << std::endl << "i: " << i;

MyClass myObject;
std::cout << std::endl << "myObject: " << myObject.getMyValue();
myObject = ++myObject;
std::cout << std::endl << "myObject: " << myObject.getMyValue();
myObject = myObject++;
std::cout << std::endl << "myObject: " << myObject.getMyValue();

Es zeigen sich zwei sehr unterschiedliche Verhaltensweisen. Die Ausgabe ist wie folgt:

i: 0
i: 1
i: 2
myObject: 0
myObject: 1
myObject: 1

Sie sehen, das Verhalten ist anders. Hier ist der Überblick über meine überladenen Operatormethoden.

MyClass & MyClass::operator++ ()
{
    ++myValue;
    return *this;
}

MyClass MyClass::operator++ (int postfixFlag)
{
    MyClass myTemp(*this);
    ++myValue;
    return myTemp;
}

Na gut. Das Präfix macht Sinn. Man inkrementiert, was auch immer man braucht, und gibt dann dasselbe Objekt, nun verändert, im Falle einer Zuweisung zurück. Aber Postfix ist das, was mich stutzig macht. Es soll erst zuweisen und dann inkrementieren. Hier sind wir selbst zuweisen. Mit dem eingebauten Integer-Typ macht es also Sinn. Ich weise zu i Wert auf sich selbst bezieht, dann i wird inkrementiert. Gut und schön. Aber sagen wir mal MyClass ist eine Nachbildung des int. Er beginnt bei 0, wird durch das Präfix erhöht und wird zu 1. Dann, die Schlüsselzeile. myObject = myObject++ . Das ist das Gleiche wie myObject = myObject.operator++(int postfixFlag) . Sie wird aufgerufen. myTemp wird mit dem Wert 1 initialisiert. Er wird auf 2 erhöht. Dann geben wir den Wert temp zurück. Das funktioniert, wenn wir es einem anderen Objekt zuweisen. Aber hier weise ich mich selbst zu, also nach der Inkrementierung auf 2, myObject wird gleich dem zurückgegebenen temp-Objekt gesetzt, das mit dem Anfangswert initialisiert wurde, und wir sind wieder bei 1! Das macht Sinn. Aber es ist ein grundlegend anderes Verhalten.

Wie kann ich sie umgehen? Wie macht int das? Wie wird diese Methode im Allgemeinen geschrieben? Haben Sie irgendwelche Anmerkungen zum Verhalten und Design von C++ in diesem Zusammenhang? Etc. Ich bin im Moment etwas ratlos, da Bücher und Online-Beispiele immer eine Variante der obigen Methode zu verwenden scheinen.

Vielen Dank fürs Lesen, und wir freuen uns über jeden Beitrag!