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 iest l'un des types intégrés.
Que faire si le type de iest un type défini par l'utilisateur? Disons que son type est Indexdé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 iest 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 += ++is'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 += ++in'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;
}
};