Problème avec les 'keys' d'un map de la STL

Problème avec les 'keys' d'un map de la STL - C++ - Programmation

Marsh Posté le 17-03-2004 à 16:37:24    

J'aimerai utiliser un type polymorphique dont chaque sous-type possède son propre opérateur < (operator< ) comme 'key' d'un map.
 
Mais le problème c'est qu'on ne peut pas donner de type pointeur comme 'key' (map<KeyType*, ...> ) donc mon 'key' que je donnerai lors d'une recherche (m[key]) sera automatiquement casté vers son parent 'KeyType' et donc c'est l'opérateur < du parent qui sera appellé.
 
J'aimerai utiliser cela pour créer des index (map) sur une table contenant des enregistrements et le but est que l'index puisse s'appliquer à différents type (int, long, str, etc..).
 
voila mon code :  
Fichier 'main.cpp'

Code :
  1. /**
  2.   * Fichier principal de test des tables en mémoire
  3.   */
  5. //désactive le warning 4786 (bug de krosoft avec les 'map' pour changer un peu)
  6. #pragma warning(disable : 4786)
  8. #include <iostream>
  9. #include <vector>
  10. #include <map>
  11. #include <list>
  12. #include <string>
  13. using namespace std;
  15. #include "baseType.h"
  18. int main(int argc, char** argv)
  19. {
  20.    //exemple d'utilisation d'index
  22.    //les définitons de type  
  23.    typedef vector<BaseType*> Record;
  24.    typedef list<Record> Table;
  25.    typedef map<BaseType, Record> Index;
  28.    //la table
  29.    Table table;
  31.    //création de trois enregistrements
  32.    Record e1(2), e2(2), e3(2);
  33.    e1[0] = new Char('a');
  34.    e1[1] = new Int(1);
  35.    e2[0] = new Char('b');
  36.    e2[1] = new Int(2);
  37.    e3[0] = new Char('c');
  38.    e3[1] = new Int(3);
  40.    //on insère les trois enregistrements (lignes)
  41.    table.push_back(e1);
  42.    table.push_back(e2);
  43.    table.push_back(e3);
  46.    //création d'un index sur le premier champs
  47.    Index index;
  48.  
  49.    //on insère successivement les enregistrements dans l'index
  50.    for(Table::iterator i = table.begin(); i != table.end(); i++)
  51.    {
  52.       index[*((*i)[0])] = (*i);
  53.    }
  54.  
  55.    //affichage de la ligne dont le champs 0 est 'b'
  56.    Record r = index[Char('b')];
  59.    cout << r[0]->getChar() ;//<< "|" << r[1]->getInt() << endl;
  61.    return 0;
  62. }


 
 
Fichier 'baseType.h' (je n'ai écrit le code que pour les type int et char)

Code :
  1. /**
  2.   * Représente une valeur de base : char, int, long, double, str
  3.   */
  5. #include <string>
  6. #include <iostream>
  7. using namespace std;
  9. class BaseType
  10. {
  11. public:
  12.    /**
  13.      * les opérateurs d'affectation pour les différents types.
  14.      */
  15.    virtual BaseType& operator=(char){return *this;};
  16.    virtual BaseType& operator=(int){return *this;};
  17.    virtual BaseType& operator=(long){return *this;};
  18.    virtual BaseType& operator=(double){return *this;};
  19.    virtual BaseType& operator=(string){return *this;};
  21.    /**
  22.      * les accesseurs.
  23.      */
  24.    virtual char getChar() const{return 0;};
  25.    virtual int getInt() const{return 0;};
  26.    virtual long getLong() const{return 0;};
  27.    virtual double getDouble() const{return 0.0;};
  28.    virtual string getString() const{return "";};
  30.    /**
  31.      * les comparaisons
  32.      */
  33.    virtual bool operator<(const BaseType& c) const{ cout << "plus petit BaseType " << endl; return false; }
  34. };
  36. /**
  37.   * Représente un caractère.
  38.   */
  39. class Char : public BaseType
  40. {
  41. public:
  42.    Char(char c):v(c){};
  43.    BaseType& operator=(char);
  44.    char getChar() const;
  45.    bool operator<(const BaseType& c) const{ cout << "plus petit Char" << endl; return this->v < c.getChar(); }
  46. private:
  47.    char v;
  48. };
  50. /**
  51.   * Représente un entier.
  52.   */
  53. class Int : public BaseType
  54. {
  55. public:
  56.    Int(int c):v(c){};
  57.    BaseType& operator=(int);
  58.    int getInt() const;
  59.    bool operator<(const BaseType& c) const{ cout << "plus petit Int" << endl; return this->v < c.getInt(); }
  60. private:
  61.    int v;
  62. };


 
 
Fichier baseType.cpp

Code :
  1. #include "baseType.h"
  3. BaseType& Char::operator=(char v)
  4. {
  5.    this->v = v;
  6.    return *this;
  7. }
  9. char Char::getChar() const
  10. {
  11.    return this->v;
  12. }
  15. BaseType& Int::operator=(int v)
  16. {
  17.    this->v = v;
  18.    return *this;
  19. }
  21. int Int::getInt() const
  22. {
  23.    return this->v;
  24. }


 
Je précise que mon code est compilable mais affiche :

plus petit BaseType
plus petit BaseType
plus petit BaseType
plus petit BaseType
plus petit BaseType
plus petit BaseType


 
Mon but serait qu'il utilise les opérateurs < des classes enfants, si vous avez une solution n'hésitez pas (même si elle n'a plus rien a voir avec ce que j'ai fait) !


Message édité par Ummon le 17-03-2004 à 18:30:24
Reply

Marsh Posté le 17-03-2004 à 16:37:24   

Reply

Marsh Posté le 17-03-2004 à 17:01:07    

Ummon a écrit :


 
Mais le problème c'est qu'on ne peut pas donner de type pointeur comme 'key' (map<KeyType*, ...> )  

si
 
 
sinon je vois ton problème. on touche la une prochaine fonctionnalité du C++ (multimethode).
 
avant de répondre : que doit il se passer si on compare 2 objets de types différents ?

Reply

Marsh Posté le 17-03-2004 à 17:09:22    

En fait un objet index porte sur le même type (par exemple int) qui représente un champs de ma table mais une table peut contenir plusieurs index, par exemple un pour un champs int et un pour un champs char (comme dans mon code-exemple).
Je n'ai pas envie de faire un type index pour chaque type de base (int, char, etc.) car mon but final et de généraliser et de mettre les index dans un vecteur, si il y a plusieurs type d'index alors cela posera problème.


Message édité par Ummon le 17-03-2004 à 17:14:15
Reply

Marsh Posté le 17-03-2004 à 17:27:59    

comment j'aurais traiter le problème avec le C++ actuel.
j'y vais un pue bourrin en laissant l'exception passé, on pourrait très bien,  
1) tenter le cast
2) tenter une conversion (avec un constructeur / operator Type)
 

Code :
  1. #include <iostream>
  4. struct Base
  5. {
  6.   virtual ~Base()
  7.   { }
  9.   virtual bool less(const Base &other) const =0;
  11. };
  15. struct Foo
  16.   : public Base
  17. {
  18.   bool less(const Foo &other) const
  19.   {
  20.     std::cout << "bool Foo::less(const Foo &other) const\n";
  21.     return this < &other;
  22.   }
  25.   virtual bool less(const Base &other) const
  26.   {
  27.     std::cout << "bool Foo::less(const Base &other) const\n";
  28.     return less(dynamic_cast<const Foo &>(other));
  29.   }
  30. };
  33. struct Bar
  34.   : public Base
  35. {
  36.   bool less(const Bar &other) const
  37.   {
  38.     std::cout << "bool Bar::less(const Bar &other) const\n";
  39.     return this < &other;
  40.   }
  43.   virtual bool less(const Base &other) const
  44.   {
  45.     std::cout << "bool Bar::less(const Base &other) const\n";
  46.     return less(dynamic_cast<const Bar &>(other));
  47.   }
  48. };
  53. inline bool operator<(const Base &lhs, const Base &rhs)
  54. {
  55.   std::cout << "bool operator<(const Base &lhs, const Base &rhs)\n";
  56.   return lhs.less(rhs);
  57. }
  59. inline bool operator<(const Foo &lhs, const Foo &rhs)
  60. {
  61.   std::cout << "bool operator<(const Foo &lhs, const Foo &rhs)\n";
  62.   return lhs.less(rhs);
  63. }
  65. inline bool operator<(const Bar &lhs, const Bar &rhs)
  66. {
  67.   std::cout << "bool operator<(const Bar &lhs, const Bar &rhs)\n";
  68.   return lhs.less(rhs);
  69. }
  75. int main()
  76. {
  77.   Base *b1, *b2;
  79.   Foo f1, f2;
  80.   Bar g1, g2;
  83.   std::cout << "Foo < Foo\n";
  84.   f1 < f2;
  85.   std::cout << '\n';
  87.   std::cout << "Bar < Bar\n";
  88.   g1 < g2;
  89.   std::cout << '\n';
  93.   b1 = &f1;
  94.   b2 = &f2;
  96.   std::cout << "Base& < Base& -> Foo < Foo\n";
  97.   *b1 < *b2;
  98.   std::cout << '\n';
  101.   b1 = &g1;
  102.   b2 = &g2;
  104.   std::cout << "Base& < Base& -> Bar < Bar\n";
  105.   *b1 < *b2;
  106.   std::cout << '\n';
  108.  
  109.   b1 = &f1;
  110.   b2 = &g1;
  112.   try
  113.     {
  114.       std::cout << "Base& < Base& -> Foo < Bar\n";
  115.       *b1 < *b2;
  116.     }
  117.   catch(std::bad_cast &ex)
  118.     {
  119.       std::cout.flush();
  120.       std::cerr << "Failed " << ex.what() << '\n';
  121.     }
  122. }


 
sinon j'ai toujours pas tout compris, je vois pas trop le problème à utiliser des index de types différents.
pusique que tes index sont du meme types, pourquoi tu utilises pas les template alors ?

Reply

Marsh Posté le 17-03-2004 à 17:44:10    

Je voudrai eviter le cast dynamique.
Ce que j'appel des index différents ca serait :
 

Code :
  1. typedef map<Int, Record> IndexInt;
  2. typedef map<Char, Record> IndexChar;
  3. etc..


 
Mais maintenant si je veux mettre mes index dans un 'vector' bein c'est plus trop possible puisqu'ils sont de type différent.
j'aurais voulu faire ça par la suite :

Code :
  1. vector<Index> indexes;


Message édité par Ummon le 17-03-2004 à 17:46:19
Reply

Marsh Posté le 17-03-2004 à 18:09:02    

ben fais le !
 
il faut juste que planque un peu le truc : tes classes Index on besoin d'avoir une base commume.
 
donc tu fais une class (abstraite?), tes classes index en hérite, et pouf, vector<Index*> et c'est gagné

Reply

Marsh Posté le 17-03-2004 à 18:19:38    

ouais c'était un peu ma solution de secours, je voulais eviter d'écrire du code supplémentaire

Reply

Marsh Posté le 17-03-2004 à 18:25:57    

cai pas une solution de secours. tu veux du polymorphisme ? ben fais en

Reply

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed