Betrachten Sie dieses Thema als Fortsetzung des folgenden Themas:
Vorherige Rate
Undefiniertes Verhalten und Sequenzpunkte
Lassen Sie uns diesen lustigen und verschlungenen Ausdruck noch einmal betrachten (die kursiven Sätze stammen aus dem obigen Thema * smile *):
i += ++i;Wir sagen, dies ruft undefiniertes Verhalten hervor. Ich nehme an, wenn wir dies sagen, nehmen wir implizit an, dass der Typ von ieiner der eingebauten Typen ist.
Was passiert , wenn die Art der iein benutzerdefinierter Typ? Angenommen, der Typ wird Indexspäter in diesem Beitrag definiert (siehe unten). Würde es immer noch undefiniertes Verhalten hervorrufen?
Wenn ja, warum? Ist es nicht gleichbedeutend mit Schreiben i.operator+=(i.operator++());oder sogar syntaktisch einfacher i.add(i.inc());? Oder rufen auch sie undefiniertes Verhalten hervor?
Wenn nein, warum nicht? Immerhin wird das Objekt zwischen aufeinanderfolgenden Sequenzpunkten zweimali geändert . Bitte erinnern Sie sich an die Faustregel: Ein Ausdruck kann den Wert eines Objekts nur einmal zwischen aufeinanderfolgenden "Sequenzpunkten ändern . Und wenn es sich um einen Ausdruck handelt, muss er undefiniertes Verhalten aufrufen. Wenn ja, dann seine Äquivalente und muss auch undefiniertes Verhalten aufrufen, das scheint falsch zu sein! (soweit ich verstehe)i += ++ii.operator+=(i.operator++());i.add(i.inc());
Oder i += ++iist nicht ein Ausdruck von Anfang an? Wenn ja, was ist es dann und wie wird der Ausdruck definiert ?
Wenn es ein Ausdruck ist, und zugleich wird ihr Verhalten auch gut definiert, dann bedeutet dies , dass die Anzahl der Sequenzpunkte mit einem Ausdruck zugeordnet ist irgendwie auf das hängt Art des Operanden im Ausdruck beteiligt. Bin ich richtig (auch nur teilweise)?
Übrigens, wie wäre es mit diesem Ausdruck?
//Consider two cases:
//1. If a is an array of a built-in type
//2. If a is user-defined type which overloads the subscript operator!
a[++i] = i; //Taken from the previous topic. But here type of `i` is Index.
Sie müssen dies auch in Ihrer Antwort berücksichtigen (wenn Sie das Verhalten sicher kennen). :-)
Ist
++++++i;in C ++ 03 gut definiert? Immerhin ist dies das,
((i.operator++()).operator++()).operator++();class Index
{
int state;
public:
Index(int s) : state(s) {}
Index& operator++()
{
state++;
return *this;
}
Index& operator+=(const Index & index)
{
state+= index.state;
return *this;
}
operator int()
{
return state;
}
Index & add(const Index & index)
{
state += index.state;
return *this;
}
Index & inc()
{
state++;
return *this;
}
};