Colle C++ : pb de template abstrait

Colle C++ : pb de template abstrait - C++ - Programmation

Marsh Posté le 18-08-2007 à 16:27:50    

J'ai un probleme interessant de template abstrait en C++.
 
Contexte: je veux faire des classes de "points 2D entiers", "points 2D geodésiques", "coordonnées polaires", etc.
 
Non seulement je veux manipuler des données de type différents (flottants, entiers, etc, d'ou nécessité d'un template), mais pour des raisons de lisibilité et de sécurité je veux nommer les membres x et y spécifiquement (ici respectivement: i & j,  lon & lat,  size & angle).
Je veux aussi pouvoir ajouter des méthodes spécifiques à ces types de coordonnées.
Enfin, hors de question dans mon cas de devoir passer par des get/set verbeux pour l'acces aux membres, je veux un accès public direct aux membres x,y et lon,lat des classes filles.
 
En gros: je veux obliger l'utilisation de "x" pour la classe "point 2D" et obliger à utiliser "lon" pour la classe "points 2D géodésique".
Comme je ne pense pas qu'il soit possible de "masquer" ou privatiser certaines variables d'un union dans des classes dérivées, ca ne doit pas etre possible avec un template qui aurait des "unions" en float sur les différents nommages x et y (il permettrait d'utiliser salement "lon" à la place de "x" et vice versa).
 
Donc la solution à laquelle je pense c'est un template abstrait avec des accesseurs get/set virtuels purs protected sur les deux membres codant les coordonnées, qui sont alors définis dans des classes dérivées et qui permettent alors un acces rapide public et un nommage spécifique.
 
Maintenant le problème est lié aux méthodes du template qui *retournent* des instances du meme type que le template: elles font malheureusement appel à une classe virtuelle pure, aie: pas le droit! Comment faire alors?
 
Voila un bout de code qui montre le problème et permet d'essayer différentes solutions:  
En attendant j'ai abdiqué et je le fais à l'ancienne, le bon vieux et moche template en pur C à base de #define paramétrés!  ;)
 

Code :
  1. #include <stdlib.h>
  2. #include <stdio.h>
  4. // Template abstrait (pur): les classes filles doivent écrire les accesseurs get/set,
  5. // ce qui leur permet de typer et nommer les membres x et y selon leur gout:
  7. template <class Type> // tiens, une autre question:  "typename" ou bien "class" ??!
  8. class PosTpl
  9. {
  10. public:
  11. int valid; // instance valide
  12. public:
  13. // Accesseurs virtuels purs à définir dans les classes filles
  14. virtual Type GetX() const = 0;
  15. virtual Type GetY() const = 0;
  16. virtual void SetX(Type v) = 0;
  17. virtual void SetY(Type v) = 0;
  19. public:
  20. // Constructeur standard
  21. PosTpl<Type>()
  22. {
  23.  valid= false;
  24. }
  26. // Arithmétique dont les classes filles hériteront:
  28. // Cette méthode est OK
  29. void operator*=(float k)
  30. {
  31.  SetX( Type(GetX() * k) );
  32.  SetY( Type(GetY() * k) );
  33. }
  35. ///--->
  36. // Mais ce constructeur est malheureusement illégal:
  37. PosTpl<Type>(Type _x, Type _y)
  38. {
  39.  SetX(_x); // <-- error: abstract virtual `void PosTpl<Type>::SetX(Type) [with Type = int]' called from constructor
  40.  SetY(_y);
  41.  valid= true;
  42. }
  44. // ...et mon gros problème c'est qu'il n'est donc pas possible d'écrire ce genre de méthodes,
  45. // qui devraient retourner une instance de classe.  :(
  46. PosTpl<Type> RotLeft()
  47. {
  48.  return PosTpl<Type>( -GetY(), GetX() );
  49. }
  50. ///---<
  52. };
  55. // exemples de classes filles:
  58. // Instanciation des templates abstraits pour les types que l'on va utiliser;
  59. // c'est logiquement requis par (certains!?) compilateurs:
  60. template class PosTpl<int>;
  61. template class PosTpl<float>;
  64. // 1) Classe dérivée: vecteur 2D entières avec acces public à x et y
  65. class PosVec : public PosTpl<int>
  66. {
  67. public:
  68. int x,y;
  69. public:
  70. // Ces constructeurs sont forcément ignorées par le template-class de base, c'aurait été trop beau
  71. //  PosVec()    { x= y= 0; valid=false; }
  72. //  PosVec(int _x, int _y) { x=_x; y=_y; }
  73. protected:
  74. int GetX() const { return x; }
  75. int GetY() const { return y; }
  76. void SetX(int _x) { x=_x; }
  77. void SetY(int _y) { y=_y; }
  78. };
  81. // 2) Exemple de classe dérivée: coordonnées géographiques flottantes avec acces public à lon et lat
  82. class PosGeo : public PosTpl<float>
  83. {
  84. public:
  85. float x,y;
  86. public:
  87. PosGeo()    { x= y= 0; valid=false; }
  88. PosGeo(int _x, int _y) { x=_x; y=_y; }
  89. protected:
  90. float GetX() const { return x; }
  91. float GetY() const { return y; }
  92. void SetX(int _x) { x=_x; }
  93. void SetY(int _y) { y=_y; }
  94. public:
  95. // Puis autres méthodes spécialisées à cette classe géo:
  96. //   PosGeo DeplacementAuCap(int direction, int distance) { ... }
  97. //  (etc)
  98. };
  102. int main(int,char**)
  103. {
  104. PosVec vec;
  105. vec.x= 12;
  106. vec.y= 10;
  107. printf("Vecteur: %d,%d\n", vec.x,vec.y);
  109. PosVec rot= vec.RotLeft();
  110. printf("Rot: %d,%d\n", rot.x,rot.y);
  111. return 0;
  112. }

Reply

Marsh Posté le 18-08-2007 à 16:27:50   

Reply

Marsh Posté le 18-08-2007 à 20:17:00    

bah le pb d'appel de virtuelle abstraite me parait independant du pb de template.
 
Ensuite, comme le disait la Mére Michel :
Melanger template et polymorphisme c'est pas bine bon.
 
Donc, le mieux c'ets de passer par une solution à base de template policy (comme expliqué dans le Alexandrescu 'Modern C+ Design')
 
en gros ca transforme ta hierarchie :
 
Point<T>, Point2D<T>, Point3D<T>, PointGeo<T>  
 
en
Point<T,_2D>
Point<T,_3D>
Point<T,Geo>
 
ou _2D,_3D, Geo sont des classes comportant des memebres de classes (prefixés par static donc) qui contiennent le code qui change entre les implantations.
 
 

Reply

Marsh Posté le 18-08-2007 à 21:02:09    

Ah oui, ça me plait davantage!
Mais là, je paye ma formation entièrement autodidacte pour le ++ du C, un peu trop vite faite à l'arrache. Ca sent donc le bouquin que je vais acheter rapidement si je ne trouve pas un exemple la de suite :)
A commencer par le fait que je n'ai encore jamais utilisé deux arguments dans un template ;)
 
Merci en tout cas pour ces infos!

Reply

Marsh Posté le 18-08-2007 à 22:27:52    

En vrac et pour commencer doucement sur les template avancée :
 
http://osl.iu.edu/~tveldhui/papers/techniques/

Reply

Marsh Posté le 18-08-2007 à 22:32:28    

Tu peux aussi chercher "traits".

Reply

Marsh Posté le 18-08-2007 à 23:03:49    

les traits c'est si peu comparé aux template policy :)

Message cité 1 fois
Reply

Marsh Posté le 18-08-2007 à 23:26:33    

Waa c'est de la bonne URL, ça, bourrée d'info!
Arretez je vais me mettre à la bourre!  :-)
 
et dire que je commençais à lorgner sur le D par curiosité...

Reply

Marsh Posté le 19-08-2007 à 18:39:10    

Joel F a écrit :

les traits c'est si peu comparé aux template policy :)


 
J'ai du mal à te comprendre.  Pour moi ce sont des choses qui se situent à des niveaux différents.
 
Les policies, qu'elles soient templates ou pas, c'est un design pattern.
 
Les traits, c'est au départ essentiellement une technique en C++ consistant à rassembler dans
un seul paramètre template une série d'entre eux.   On arrive donc à des structs n'ayant que des
membres statiques.  Quand ces paramètres concernent un type, on la paramètrise généralement
par ce type.
 
Certaines conceptions à base de politiques peuvent être implémentées avec des traits en C++.  Ca
me semble être le cas pour ce problème.

Reply

Marsh Posté le 19-08-2007 à 19:06:20    

je me suis mal exprimé. Dans ma tête, je voyais juste les traits tel que fournit par la STL. Mea culpa donc. :jap:

Reply

Sujets relatifs:

Leave a Replay

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