Considérez ce sujet comme une suite du sujet suivant:
Épisode précédent
Comportement et points de séquence non définis
Revisitons cette expression drôle et alambiquée (les phrases en italique sont tirées du sujet ci-dessus * sourire *):
i += ++i;
Nous disons que cela invoque un comportement indéfini. Je présume que lorsque vous dites cela, nous supposons implicitement que le type de i
est l'un des types intégrés.
Que faire si le type de i
est un type défini par l'utilisateur? Disons que son type est Index
défini plus loin dans ce post (voir ci-dessous). Invoquerait-il toujours un comportement indéfini?
Si oui, pourquoi? N'est-ce pas équivalent à l'écriture i.operator+=(i.operator++());
ou même syntaxiquement plus simple i.add(i.inc());
? Ou, invoquent-ils eux aussi un comportement indéfini?
Si non, pourquoi pas? Après tout, l'objet i
est modifié deux fois entre des points de séquence consécutifs. Rappelez-vous la règle empirique: une expression ne peut modifier la valeur d'un objet qu'une seule fois entre "points de séquence consécutifs" . Et s'il i += ++i
s'agit d'une expression, elle doit invoquer un comportement indéfini. Si tel est le cas, ses équivalents i.operator+=(i.operator++());
et i.add(i.inc());
doit également invoquer un comportement indéfini qui semble être faux! (pour autant que je sache)
Ou i += ++i
n'est-ce pas une expression pour commencer? Si oui, qu'est-ce que c'est et quelle est la définition de l' expression ?
S'il s'agit d'une expression, et en même temps, son comportement est également bien défini, cela implique que le nombre de points de séquence associés à une expression dépend en quelque sorte du type d'opérandes impliqués dans l'expression. Ai-je raison (même partiellement)?
Au fait, qu'en est-il de cette expression?
//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.
Vous devez également en tenir compte dans votre réponse (si vous connaissez son comportement avec certitude). :-)
Est
++++++i;
bien défini en C ++ 03? Après tout, c'est ça,
((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;
}
};