Créer une map avec un type comme clé

Bonjour,


J'aimerai savoir s'il était possible de faire un dictionnaire prenant en clé un type.
En effet, j'ai un module qui doit référencer certaines classes et leur attribuer un nom.

Par exemple :
CClient = "clients"
CVoitures = "voitures"

Dans mon module j'aimerai retrouver la valeur par ce genre d'instruction :
std::string sCode = maMap[CClient];

Est-ce que c'est possible ?


Merci beaucoup,

A bientôt

Et bien je dirais que tu as soit la solution facile avec une map<string,string> :

Code:

---

std::string sCode = maMap["CClient"];

---

Ou alors il y a des solutions plus évoluées mais aussi bien plus complexes à base de méta programmation.

Il est peut-être aussi possible d'utiliser une astuce à base de valeur de retour de type_info(), mais je perso je ne recommanderais pas une telle bidouille.

Oui là justement ça reste une chaîne de caractère la clé.

Il y a quoi comme solution ? Est-ce que il faut regarder du côté des typelist ?

Oui, c'est à ça que je pensais.
L'ennui c'est que, d'une part, il est probable que tu doives te refaire ta propre typelist spécialisée à partir de rien. Ensuite, le stockage des chaines de caractères en tant que paramètre template ce n'est pas simple. Je crois que Boost contient quelque chose pour simplifier ça (si ça dit quelque chose à un lecteur...).

Edit: je viens de penser à quelque chose de plus simple, à base de classes de traits:

Code:

---

1 2 3 4 5 6 7 8 9 10 11

template<class A> struct classname { static const char* name="unknown"; };   template<> struct classname<machin> { static const char* name="machin"; }   ...

---

Quelques macros par dessus ça et ça devrait être fonctionnel (quoique, je suis pas certain que des const char* en static ça passe correctement écrit comme ça)

Edit2: Effectivement non, par contre de cette façon c'est bon:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

template<class A> struct classname { static string name() { return "unknown"; } };   template<> struct classname<machin> { static string name() { return "machin"; } };

---

Et pourquoi pas des const std::string à la place de ces const char* ?

Ok, merci beaucoup,

Je vais faire quelques recherches et tester 2-3 trucs.

Merci :)

Encore moins, j'avais un doute sur const char* mais avec une classe je suis certain que ça ne passera jamais sans définir quelque chose dans le cpp.

Salut,

Tout type capable d'apporter une réponse à une comparaison de type "plus petit que" peut être utilisé comme clé.

Le tout, est qu'il faudra sans doute prévoir un foncteur permettant de mettre cette comparaison en oeuvre.

Le cas échéans, tu pourrais même tout à fait envisager un comportement polymorphique grâce à une arborescence correcte.

Ainsi, une classe proche de

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

class MaCle { public: MaCle(/*paramètres éventuels */); /*virtual */ ~MaCle(); struct less { bool operator()(const MaCle& c1, const MaCle& c2) { /* toute la logique permettant de déterminer c1<c2 */ } }; /* il peut y avoir d'autres méthodes */ private: /* les membres de la classe */ },

---

pourra sans aucun problème être utilisé comme clé dans une std::map.

Elle sera utilisée sous une forme proche de

Code:

---

std::map<MaCle, objetGere, MaCle::less > lamap;

---

et tu pourrais tout à fait effectuer une recherche sous une forme proche de

Code:

---

1 2 3 4

if( lamap.find(MaCle(/* paramètres nécessaires */)!=lamap.end()) { /*l'objet existe dans la map */ }

---

ou, si tu préfère l'écriture "conventionnelle":

Code:

---

1 2 3 4 5

MaCle tofind/* (paramètres nécessaires) */; if(lamap.find(tofind) != lamap.end()) { /* bla, bla bla */ }

---

Koala, il ne parlait pas d'associer des instances d'un type à des chaines de caractères, mais directement des types à des chaines de caractères, ce qui n'est pas à proprement parler une donnée et n'est pas utilisable avec std::map.

Au temps pour moi... j'avais effectivement mal compris le sens de la question.

Ceci dit, il reste malgré tout parfaitement possible de s'en sortir, pour autant de partir sur un héritage appelé de réalisation:

L'idée est simple: plutôt que de rajouter des membres à une classe de base dans une classe dérivée, on veille à ce que tous les membres utiles se trouvent dans la classe de base - de manière à éviter les problèmes de perte d'informations si une classe dérivée se fait passer pour une classe de base - et à spécialiser tout simplement le constructeur.

En effet, le polymorphisme au niveau de la clé doit être résolu à l'utilisation, et non à la compilation (ce qui disqualifie l'utilisation des template, du moins pour la classe de base).

Ce n'est pas "très orthodoxe", mais tu pourrais envisager une arborescence proche de

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

class MaCle { public: MaCle(size_t mtype): mtype(mtype){} ~MaCle(){} /* le prédicat permettant de comparer deux éléments de type MaCle   * est à rajouter ;) */ private: size_t mtype; }; class CClient : public MaCle { public: CClient():MaCle(1){} }; class CVoiture : public MaCle { public: CVoiture():MaCle(2){} }; /* et tous les autres types qu'il faudrait utiliser comme clé */

---

La déclaration du tableau associatif s'effectuerait sous une forme proche de
std::map<MaCle, std::string> lamap;
Les méthodes d'ajout et de recherche de la chaine de caractères correspondante seraient classique:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

void MonContener::insert(const MaCle& c, const std::string& str) { lamap.insert(std::make_pair(c,str)); } const std::string& MonContener::find(const MaCle & c) { std::map<MaCle,std::string>::iterator it=lamap.find(c); if(it==lamap.end()) { /* prévoir le cas où l'élément n'est pas trouvé... */ } return (*it).second; }

---

et les appels pourraient s'effectuer sous une forme proche de
MonConteneur ct;

Code:

---

1 2 3 4 5 6

/*...*/ ct.insert(CVoiture(),"voiture"); ct.insert(CClient(),"client"); /*...*/ std::string str=ct.find(CClient()); std::string str2=ct.find(CVoiture());

---

et le tout fournirait le comportement recherché ;)

Mais, l'un dans l'autre, je me dis qu'il serait surement plus intéressant encore d'utiliser de préférence une énumération (par exemple) comme clé...

Il est, en effet, facile de fournir une méthode qui renvoie une telle valeur à toutes les classes qui en ont besoin (sans qu'elles soient forcément liées par un héritage commun), et, par voie de conséquence, de récupérer la chaine de caractères qui correspond ;)

Ce que tu veux c'est une simple correspondance type -> chaîne.
Or une correspondance type -> quelque chose, ça s'obtient tout simplement avec des classes templates spécialisées.

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

template<typename T> struct name { };   template<> struct name<Type1> { // exposition de la chaîne d'une manière ou d'une autre };   etc.

---

Merci beaucoup à vous,

Je vais prendre la solution de Loufoque.

Merci :)

Citation:

---

Envoyé par loufoque

Ce que tu veux c'est une simple correspondance type -> chaîne.
Or une correspondance type -> quelque chose, ça s'obtient tout simplement avec des classes templates spécialisées.

---

Que l'on appelle classes de traits. (voir FAQ C++ du site et Modern C++ Design pour approfondir)

Pour info, ne te lances pas la-dedans si tu veux faire du 'dynamique' car il faut que le type de la classe soit explicitement écrit dans le code pour que cela fonctionne (par explicitement, je compte aussi les instanciations de template ou T est remplacé). Mais peut-être veux-tu juste faire du statique ?

Peux-tu nous dire comment sera utilisé ton dictionnaire dans le code ?

NiamorH >> n'oublie pas aussi l'article de Alp sur les traits et politiques.

Alp sait déjà que j'ai une dent contre lui :lol: ;) ;)