test sur clé enumeration

Version imprimable

19/07/2006, 12h38
jolatouf

test sur clé enumeration
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:

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:

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
19/07/2006, 12h44
Matthieu Brucher

Citation:

Envoyé par jolatouf

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 :(
19/07/2006, 12h47
jolatouf

Euh :oops: 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
19/07/2006, 13h17
Matthieu Brucher

Un std::set ?
19/07/2006, 13h18
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...
19/07/2006, 13h28
jolatouf

Merci,

je vais etudier tous cela.
19/07/2006, 13h44
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:

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.
19/07/2006, 13h46
Matthieu Brucher

Mouais... le std::map sert à faire la même chose en plus élégant.
19/07/2006, 13h53
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.
19/07/2006, 13h54
jolatouf

Merci Luther,

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

merci quand meme
19/07/2006, 14h03
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.

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

Code:

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:

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

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

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

19/07/2006, 23h13
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.