Discussion :

[balabare]

Bonjour tout le monde!

J'ai été amené à faire un code... bizarre et je me demandais s'il n'y avait pas une meilleure pratique.

J'ai une énumération (type enum) d'environ 100 éléments dont je génère la définition depuis un fichier de spécification à l'aide d'un script. Cela crée un fichier, mettons "long_enum.h"

J'aimerais que le type enum soit dans le namespace d'une classe, mais n'aimerais pas encombrer le fichier de définition de la classe avec cette longue énumération. Donc j'ai fait:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
#include <iostream>
 
class Property{
public:
    //inclusion de l'enum
#include "long_enum.h"
...
};
 
int main{int argc, char** argv)
{
    //un appel:
    std::cout<<Property::element_de_l_enum<<std::endl;
    return 0;
}

ça marche, mais je n'ai jamais vu ce genre de chose... Peut-on faire dans la classe une pré-définition de l'enum et effectivement en définir les membres plus loin?

Merci!

[3DArchi]

Salut,
Il faut bien comprendre la différence entre le pré-processing et la compilation.
En gros, le pré-processing triture ton fichier source pour produire un fichier source intermédiaire qui lui sera compilé. Quand tu compile toto.cpp. Le pré-processeur construit un fichier intermédiaire avec le contenu de toto.cpp dans lequel toutes les lignes #include "tutu.h" ont été remplacées par le contenu du fichier tutu.h.
Donc tu peux très bien avoir un fichier mes_donnees.txt qui serait comme ça:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
un_nom_1,
un_nom_2,
un_nom_3,
...
un_nom_4,

Puis un fichier d'en-tête:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
class A
{
   enum MonEnum{
#include "mes_donnees.txt"
   };
// déclarations ...
};

Un fichier source :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
#include "A.h"
// implémentation ...

A l'issue du pré-processing, le compilateur aura à compiler un code qui serait :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
 
class A
{
   enum MonEnum{
un_nom_1,
un_nom_2,
un_nom_3,
...
un_nom_4,
   };
// déclarations ...
};
 
// implémentation ...

Ce qui est manifestement un code C++ tout à fait valide.

[balabare]

Oui!

Je m'inquiétais surtout pour la lisibilité du code.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
class A
{
   enum MonEnum{
#include "mes_donnees.txt"
   };
// déclarations ...
};

me semble préférable à ce que j'ai fait (même si, après le préprocesseur ça revient au même), c'est plus lisible puisqu'on voit directement le type enum dans la déclaration.

Merci pour la réponse!

[3DArchi]

Effectivement, ça nuit à la lisibilité...
Ceci dit, les compilateurs ont souvent une option permettant de s'arrêter après la phase de pré-compilation pour voir le fichier effectivement compilé.
A cela j'ajouterais que Boost.Preprocessor est basée sur ce principe et que beaucoup de bibliothèques Boost l'utilisent aussi (notamment en l'absence des variatic templates).