Le comportement « i = i » est-il toujours indéfini en C ?

Comportement non défini et points de séquence revisités

Comportement non défini pour les types intégrés

Dans un épisode précédent, "Comportement non défini et points de séquence", nous avons discuté du comportement potentiel indéfini associé à l'expression :

i += ++i;

Quand je suis un type intégré, cette expression invoque un comportement non défini car l'objet i est modifié deux fois entre des points de séquence consécutifs.

Comportement non défini pour les types définis par l'utilisateur

Cependant, si i est un type défini par l'utilisateur type, tel que la classe Index définie ci-dessous :

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;
        }
};

L'expression i = i invoquerait-elle toujours undéfini comportement ?

Comportement bien défini pour les opérateurs surchargés

Étonnamment, non. L'expression i = i avec un type i défini par l'utilisateur n'invoque pas de comportement non défini car les opérateurs surchargés sont considérés comme des fonctions en C . Selon la section 1.9.17 de la norme C ISO :

Lors de l'appel d'une fonction (que la fonction soit en ligne ou non), il y a un point de séquence après l'évaluation de tous les arguments de la fonction...

Par conséquent, les appels aux fonctions Operator et Operator = introduisent des points de séquence, empêchant un comportement indéfini.

Comportement non défini pour a[ i] = i

L'expression a[ i] = i est également bien définie lorsque a est un type défini par l'utilisateur avec un opérateur d'indice surchargé, car elle est considérée comme un appel de fonction avec un point de séquence après avoir évalué l'expression i .

Comportement bien défini pour i

En C 03, l'expression i est bien définie, car effectivement équivalente à :

((i.operator++()).operator++()).operator++();

Avec chaque appel de fonction introduisant un point de séquence, rendant l'expression bien définie.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!