Considera questo argomento un sequel del seguente argomento:
Puntata precedente
Comportamento indefinito e punti di sequenza
Rivisitiamo questa espressione divertente e contorta (le frasi in corsivo sono prese dall'argomento sopra * smile *):
i += ++i;
Diciamo che questo richiama un comportamento indefinito. Presumo che quando si dice questo, si presume implicitamente che il tipo di isia uno dei tipi predefiniti.
E se il tipo di iè un tipo definito dall'utente? Diciamo che il suo tipo è Indexdefinito più avanti in questo post (vedi sotto). Invocerebbe ancora un comportamento indefinito?
Se sì, perché? Non è equivalente alla scrittura i.operator+=(i.operator++());o anche sintatticamente più semplice i.add(i.inc());? Oppure invocano anche un comportamento indefinito?
Se no, perché no? Dopo tutto, l'oggetto iviene modificato due volte tra punti di sequenza consecutivi. Ricorda la regola pratica: un'espressione può modificare il valore di un oggetto solo una volta tra "punti di sequenza" consecutivi . E se i += ++iè un'espressione, deve invocare un comportamento non definito. In tal caso, i suoi equivalenti i.operator+=(i.operator++());e i.add(i.inc());deve anche richiamare un comportamento non definito che sembra essere falso! (per quanto ho capito)
Oppure i += ++inon è un'espressione per cominciare? In caso affermativo, cos'è e qual è la definizione di espressione ?
Se è un'espressione, e allo stesso tempo, è il suo comportamento anche ben definito, allora implica che il numero di punti sequenza associati con un'espressione dipende in qualche modo il tipo di operandi coinvolte nell'espressione. Ho ragione (anche in parte)?
A proposito, che ne dici di questa espressione?
//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.
Devi considerare anche questo nella tua risposta (se conosci con certezza il suo comportamento). :-)
È
++++++i;
ben definito in C ++ 03? Dopotutto, questo è questo,
((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;
}
};