templates et polymorphisme

Bonjour à tous,

Voilà mon souci du moment :

J'ai une interface :

Code:

---

1 2 3 4 5 6

class IProperty { public: virtual std::string ToString() = 0; };

---

Puis qui en hérite une propriété conrête, templarisée

Code:

---

1 2 3 4 5 6 7 8 9 10 11

template<class T> class CProperty { typedef T value_type;   public: virtual std::string ToString(); private: T m_tValue; };

---

Ce qui me dérange, c'est que lorsque je dois comparer deux "IProperty", je ne peux pas savoir si je peux comparer les types encapsules entre eux ou devoir passer par la conversion en chaîne de caractères...

Code:

---

1 2 3 4 5 6 7

IProperty& lProperty = CProperty<long>(10); IProperty& strProperty = CProperty<std::string>("10"); lProperty == strProperty; // On passe par les "ToString()", ok   IProperty& lProperty2 = 20; lProperty2 == lProperty1; // On passe toujours par les ToString mais j'aimerai passer par la comparaison entre "long" pour gain de perfs

---

Comment je peux résoudre le problème ? Est-t-il possible de mettre une fonction virtuelle pure qui renvoi non pas une valeur, une référence ou un pointeur mais un type afin de les passer à une structure Trait qui les comparera ?


Merci beaucoup,

A bientôt

Typiquement, pour ça, on passe par des traits et une valeur retournée.
Le problème, c'est que ça restreint à un sous-ensemble de types (généralement, les types primitifs + un ou deux types "pointeur", sachant qu'on peut considérer std::string comme primitif dans le cas présent).

Voir aussi boost::variant, qui pourrait t'aider de ce côté-ci.

Merci pour ta réponse.

Est-ce que tu peux me donner un bout de code avec la solution des traits ? car j'ai essayé sans succès :'(


Merci

Typiquement, les traits donnent un truc de ce genre:

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 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70

#include <string>   enum PropertyType { PropertyInt16, PropertyInt32, PropertyChar, PropertyString, PropertySingleFloat, PropertyDoubleFloat, PropertyPointer };   template< class T > struct PropertyTypeTraits { };   template<> struct PropertyTypeTraits<short> { enum TypeValues { TypeValue = PropertyInt16 }; };   template<> struct PropertyTypeTraits<int> { enum TypeValues { TypeValue = PropertyInt32 }; };   template<> struct PropertyTypeTraits<long> { enum TypeValues { TypeValue = PropertyInt32 }; };   template<> struct PropertyTypeTraits<std::string> { enum TypeValues { TypeValue = PropertyString }; };   //Spécialisation partielle pour les pointeurs template<class T> struct PropertyTypeTraits<T*> { enum TypeValues { TypeValue = PropertyPointer }; };   class IProperty { public: virtual PropertyType GetPropertyType() = 0; virtual std::string ToString() = 0; };   template<class T> class CProperty { typedef T value_type;   public: virtual PropertyType GetPropertyType() { return static_cast< PropertyType >( PropertyTypeTraits< T >::TypeValue ); } virtual std::string ToString(); private: T m_tValue; };   void TestTemplate3(void) { CProperty< int > prop; PropertyType type = prop.GetPropertyType();   (void)type; }

---

Merci beaucoup :)

Je test ça de suite

Pas besoin de faire des choses aussi verbeuses et surtout aussi fixes.
Si typeid(lProperty) == typeid(lProperty1), alors c'est le même type.

Ah, merci Loufoque. J'oublie toujours la RTTI en C++, et surtout s'il est question de la mêler aux templates...

CProperty n'hérite pas de IProperty ? Je pensais que c'était une coquille.
Ça n'a rien à voir avec les templates.

Je pense que c'est une coquille.

Bah si si, CProperty hérite de IProperty.

J'ai utilisé le typeid finalement, ça fonctionne bien.


Merci :)