Pourquoi ne puis-je pas initialiser les membres de données de classe en C à l'aide de la syntaxe d'initialisation directe ?

Pourquoi l'initialisation des membres de données de classe avec une syntaxe directe est interdite en C

Les programmeurs peuvent se demander pourquoi les membres de données de classe ne peuvent pas se voir attribuer des valeurs à l'aide d'une syntaxe d'initialisation directe, similaire à la façon dont les membres de données de classe les variables peuvent. Prenons l'exemple suivant :

class test
{
    public:
        void fun()
        {
            int a(3);
            std::cout << a << '\n';
        }
    private:
        int s(3);    // Compiler error: Why???
};

Lors de la compilation de ce code, des erreurs se produiront :

11    9 [Error] expected identifier before numeric constant
11    9 [Error] expected ',' or '...' before numeric constant

Pourquoi cela se produit-il ? Passons en revue la position de la norme C sur l'initialisation des membres de données de classe.

Ambiguïté de l'analyse

Les premières propositions pour la syntaxe d'initialisation directe expliquaient qu'elle était exclue pour éviter les problèmes d'analyse. Par exemple, considérons le code suivant :

struct S {
    int i(x); // data member with initializer
    // ...
    static int x;
};

struct T {
    int i(x); // member function declaration
    // ...
    typedef int x;
};

Si l'initialisation directe était autorisée, l'analyse de la déclaration de la structure S deviendrait ambiguë. Le compilateur pourrait interpréter int i(x); soit en tant que données membres avec un initialiseur, soit en tant que déclaration de fonction membre avec un paramètre.

Règles de résolution existantes

Une solution consiste à s'appuyer sur la règle selon laquelle si une déclaration peut être interprétée à la fois comme un objet et une fonction, il doit être traité comme une fonction. Cependant, cette règle existe déjà pour les déclarations de portée bloc, ce qui entraîne une confusion potentielle :

struct S {
    int i(j); // ill-formed...parsed as a member function,
              // type j looked up but not found
    // ...
    static int j;
};

Une autre solution consiste à utiliser la règle selon laquelle si une déclaration peut être interprétée à la fois comme un type et comme autre chose, elle doit être traité comme ce dernier. Encore une fois, cette règle existe déjà pour les modèles :

struct S {
    int i(x); // unabmiguously a data member
    int j(typename y); // unabmiguously a member function
};

Cependant, ces deux solutions introduisent des subtilités sujettes à des malentendus.

Solution proposée

Pour lever ces ambiguïtés, le standard C proposait d'autoriser uniquement les initialiseurs des formes suivantes :

• = initializer-clause
• { initializer-list }

Cela résout l'ambiguïté dans la plupart des cas et évite le besoin de règles supplémentaires.

En résumé, l'interdiction de La syntaxe d'initialisation directe pour les données membres de classe en C provient de l'analyse des ambiguïtés qui pourraient survenir lors de la déclaration de structures de données complexes impliquant à la fois des données membres et des déclarations de fonctions ou des définitions de types avec des valeurs similaires. signatures.

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!