Discussion :

[jolatouf]

Bonjour,

Je suis entrain de faire une grammaire et afin de simplifier le code pour de futur evolution, je cherche a me servir des enumerations.

Pour utiliser cette grammaire l'utilisateur entre une serie de lettre.

Code :

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

1
2
3
4
5
 
//lettre presente dans la grammaire
enum grammarLetter{
	A,T,R,X,D,E,I
	};

L'utilisateur rentre donc une chaine de caractere que je redecoupe en char pour savoir chaque lettre utilisée.

En faite j'aimerai faire quelque chose du genre :

Code :

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

1
2
3
4
5
6
7
 
char monOccurrence; //lettre de la grammaire a traiter
 
if(monOccurence est une lettre de ma grammaire present dans mon enum)
   return true;
sinon
   return false;

Je sais qu'une enum permet de representer une chaine par un int mais ma question est peut on faire le test sur la clé de l'enum.

Merci

[Matthieu Brucher]

Je sais qu'une enum permet de representer une chaine par un int mais ma question est peut on faire le test sur la clé de l'enum.

Ce n'est pas exactement ça, on représente dans le fichier .cpp un entier par un nom de variable, pas par une chaîne de caractères. Quand le programme est compilé, le nom A, E, ... n'existe plus, il ne reste que la valeur

[jolatouf]

Euh oui desoler je voulait dire variable pas chaine.

Donc ce que j'essaye de faire n'est pas ce qu'il y a de plus simple un tableau ou une autre structure serait peut etre plus aproprié?

Merci de ton aide

[Matthieu Brucher]

Un std::set ?

[Médinoc]

Ou un tableau associatif (std::map) plutôt, non?
Encore que si tu ne cherches que sur des caractères, une Lookup Table serait à la fois plus économique en temps, en code et peut-être même en mémoire...

[jolatouf]

Merci,

je vais etudier tous cela.

[Luther13]

S'il s'agit de verifier qu'un caractère est present dans l'enum,tu peux faire une fonction à ta sauce qui effectue le boulot.

Code :

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

1
2
3
4
5
6
7
8
9
10
 
grammarLetter getEnumGrammer(char o)
{
    switch(o)
    {
     case 'A': return A;
     case 'T': return T;
.....
    }
}

Un operateur de cast enum en char peut être interessent si l'on se trouve dans une classe.

[Matthieu Brucher]

Mouais... le std::map sert à faire la même chose en plus élégant.

[Médinoc]

Mais je trouve que std::map, c'est un peu la grosse artillerie.
Pour des caractères ASCII, une Lookup Table avec une entrée par caractère (128 ou 256 entrées, quoi) pourrait être plus appropriée.

[jolatouf]

Merci Luther,

mais c'est justement pour eviter cela que je cherche une structure plus propre ou elegante...

merci quand meme

[Luther13]

OK.
Je ne sais pas s'il faut parler de propreté ou d'élégance,
mais le dilemme entre ces deux methodes se trouve dans le tandem
allocation memoire (map) ou utilisation du processeur (appel de fonction).

Alors en terme d'optimisation, je prefère mon simple appel de fonction.

[Médinoc]

Luther13: La lookup table serait peut-être plus économique que ton switch aussi, tu sais...

Code C++ :

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
17
18
19
20
21
22
23
24
#include <iostream>
 
//lettre presente dans la grammaire
//Evidemment, il faudra faire plus propre que "une seule lettre" plus tard
enum grammarLetter{
        _=0,
        A,T,R,X,D,E,I
        };
 
grammarLetter LookupTableAlpha[26] = {A,_,_,D,E,_,_,_,I,_,_,_,_,_,_,_,_,R,_,T,_,_,_,X,_,_};
 
grammarLetter getEnumGrammer(char o) {
        if( o >= 'A' && o <='Z' ) {
                return LookupTableAlpha[o-'A'];
        } else {
                return _;
        }
}
 
int main(void)
{
for(char i='A' ; i<='Z' ; i++)
        std::cout << i << " : " << getEnumGrammer(i) << std::endl;
}

Edit: Testé et corrigé.

Code en sortie :

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
17
18
19
20
21
22
23
24
25
26
27
$>./testEnum
A : 1
B : 0
C : 0
D : 5
E : 6
F : 0
G : 0
H : 0
I : 7
J : 0
K : 0
L : 0
M : 0
N : 0
O : 0
P : 0
Q : 0
R : 3
S : 0
T : 2
U : 0
V : 0
W : 0
X : 4
Y : 0
Z : 0

[Laurent Gomila]

Faire une recherche linéaire sur 7 éléments ce n'est pas la mort non plus

Code :

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

1
2
3
4
5
6
static const std::string Characters = "ATRXDEI";
 
if (Characters.find(c) != std::string::npos)
    Trouvé
else
    Pas trouvé

[Luc Hermitte]

- pas sûr qu'il y ait un intérêt à redescendre au niveau du caractère
- il existe déjà quantité de parsers -> boost.spirit, antlr, lex/yaxx, ...
- Préférant généralement générer mes enums, je me retrouve par la même occasion avec des tableaux triés de chaînes -- sur lesquels j'ai les accès directs pour le passage enum->chaîne, et l'accès en O(ln n) pour le passage chaine -> enum
- Une bonne pratique avec les énums, c'est d'avoir une valeur de garde inatégnable. Si les valeurs sont consécutives, alors il suffit de tester par à ce max.