Probleme(s) sur les Template

Probleme(s) sur les Template - C++ - Programmation

Marsh Posté le 08-12-2009 à 19:25:01    

Bonsoir tout le monde,
 
j'ai une classe Fraction (qui fait partie d'un package Maths) que j'ai du passer en Template, maintenant elle s'appelle FractionG
 
Alors j'ai normalement fait toute les modification adéquate mais le test unitaire de mes surcharges =, ==, != ne fonctionne pas (en prenant l'exemple sur ma MatriceG).
Sinon pour les comparaisons sur des entiers je n'ai pas d'erreur mais il me sort "template class has already been defined" au build
PS : le code qui ne fonctionne pas est en commentaire.
 
voici le code FractionG_2.cpp :  

Code :
  1. //
  2. // IUT de Nice / Departement informatique / Module APO-C++
  3. // Annee 2009_2010 - Feuille_6
  4. //
  5. // Classe FractionG : Surcharge opérateurs =, ==, !=
  6. //
  7. // Auteurs : C. Mus & S. Funel
  8. //
  10. #ifndef _FractionG
  11. #include "FractionG.h"
  12. #endif
  15. // --- Surcharge de l'opérateur = avec une FractionG
  16. //
  17. template <class G>
  18. FractionG <G> &FractionG <G>::operator =(const FractionG& f) {
  20. m_numerateur= f.m_numerateur ;
  21. m_denominateur= f.m_denominateur ;
  22. return *this ;
  23. }
  25. // --- Surcharge de l'opérateur = avec un entier
  26. //
  27. template <class G>
  28. FractionG <G> &FractionG <G>::operator =(int op) {
  30. m_numerateur= op ;
  31. m_denominateur= 1 ;
  32. return *this ;
  33. }
  36. // --- Surcharge de l'opérateur == comparaison entre deux FractionGs
  37. //
  38. template <class G>
  39. bool FractionG <G>::operator ==(const FractionG& f) {
  41.    // Controler les produits croisés
  42.    //
  43.    return numerateur()*f.denominateur() == f.numerateur()*denominateur(); // Edit, Erreur corrigé
  44. }
  47. // --- Surcharge de l'opérateur == comparaison entre une FractionG et un entier
  48. //
  49. template <class G>
  50. bool FractionG <G>::operator ==(int op) {
  52.    // Controler le produit croise
  53.    //
  54.    return numerateur() == op*denominateur();
  55. }
  58. // --- Surcharge de l'opérateur != comparaison entre deux FractionGs
  59. //
  60. template <class G>
  61. bool FractionG <G>::operator !=(const FractionG& f) {
  63.    // Controler le produit croise
  64.    //
  65. return numerateur()*f.denominateur() != f.numerateur()*denominateur();
  66. }
  69. // --- Surcharge de l'opérateur != comparaison entre une FractionG et un entier
  70. //
  71. template <class G>
  72. bool FractionG <G>::operator !=(int op) {
  74.    // Controler le produit croise
  75.    //
  76.    return numerateur() != op*denominateur();
  77. }


 
Et voici mon test unitaire :  

Code :
  1. //
  2. // IUT de Nice / Departement informatique / Module APO-C++
  3. // Annee 2009_2010 - Package _Maths
  4. //
  5. // Classe FractionG - Tests unitaires des operateurs == et !=  
  6. //                   (cas nominaux)
  7. //
  8. // Auteur : S. Funel & C. Mus
  9. //
  11. #ifndef _FractionG_
  12. #include "..\_SRC\FractionG.h"
  13. #endif
  15. #include "..\_SRC\FractionG.cpp"
  16. #include "..\_SRC\FractionG_2.cpp"
  17. #include "T:\_Tests\Tests\Tests.h"
  19. void main () {
  21.    Tests::Begin("_Maths.FractionG", "2.0.0" );
  23.       Tests::Design("Controle des operateurs (Premiere partie)", 3);
  25.          /*Tests::Case("Operateur == : comparaison de deux FractionG" ); {
  26.          
  27.      FractionG f1(3,3);
  28.   Fraction f2(5), f3(-3), f4(6);
  29.   int f5(2,1), f6(12,6), f7(3,1), f8(-3,1);
  30.   int f9(10,5), f10(-10,-5);
  32.             Tests::Unit(0,  f1==f2);
  33.             Tests::Unit(1,  f3==f4);
  34.             Tests::Unit(1,  f5==f6);
  35.             Tests::Unit(0,  f7==f8);
  36.             Tests::Unit(0,  f9==f10);
  37.   Tests::Unit(1,  f2==f9);
  38.          }*/
  40.          Tests::Case("Operateur == : comparaison avec un entier" ); {
  42.   int f1(2),  f2(-2), f3(0), f4(0);
  44.             Tests::Unit(1,  f1==2);
  45.             Tests::Unit(1,  f2==-2);
  46.             Tests::Unit(1,  f3==0);
  47.             Tests::Unit(0,  f4==-1);
  48.          }
  50.          /*Tests::Case("Operateur != : comparaison de deux FractionGs" ); {
  51.   int f1(2),  f2(7), f3(-2), f4(2);
  52.   int f5(2), f6(-4), f7(1), f8(1);
  54.             Tests::Unit(1,  f1!=f2);
  55.             Tests::Unit(1,  f3!=f4);
  56.   Tests::Unit(0,  f4!=f5);
  57.             Tests::Unit(1,  f5!=f6);
  58.             Tests::Unit(0,  f7!=f8);
  59.          }*/
  60.      
  61.          Tests::Case("Operateur != : comparaison avec un entier" ); {
  62.   int f1(2),  f2(4), f3(-1), f4(-1);
  64.             Tests::Unit(0,  f1!=2);
  65.             Tests::Unit(1,  f2!=-2);
  66.             Tests::Unit(1,  f3!=0);
  67.             Tests::Unit(0,  f4!=-1);
  68.          }
  70.       Tests::Design("Controle des operateurs (Deuxieme partie)", 3);
  72.          /*Tests::Case("Operateur = : cas de deux FractionGs" ); {
  73.          FractionG& <FractionG> f1(2,3),  f2(5,4);
  74.          FractionG& <FractionG> f(0);
  76.             f=f1;  Tests::Unit(1, f==f1);
  77.                    Tests::Unit(0, f==f2);
  78.             f1=f2; Tests::Unit(0, f1==f);
  79.                    Tests::Unit(1, f1==f2);
  80.          }
  82.          Tests::Case("Operateur = : cas d'un entier" ); {
  83.          FractionG& <FractionG> f(-1);
  85.             f=0; Tests::Unit(0, f==1);
  86.                  Tests::Unit(1, f==0);
  87.                  Tests::Unit(1, f==-0);
  88.             f=7; Tests::Unit(0, f==0);
  89.                  Tests::Unit(1, f==7);
  90.          }
  91. */
  92.    Tests::End();
  93. }


 
Merci beaucoup d'avance.
 
Philip Masse


Message édité par Philip Masse le 09-12-2009 à 09:42:39
Reply

Marsh Posté le 08-12-2009 à 19:25:01   

Reply

Marsh Posté le 08-12-2009 à 20:03:22    

C'est normal le  return <G> ligne 43?


---------------
The truth is rarely pure and never simple (Oscar Wilde)
Reply

Marsh Posté le 08-12-2009 à 20:13:58    

Petite erreur, merci :)
Corrigé !

Reply

Marsh Posté le 08-12-2009 à 22:21:12    

on en mets pas le corps d'un template dans un .cpp mais dans un .h


Message édité par Joel F le 08-12-2009 à 22:21:43
Reply

Marsh Posté le 09-12-2009 à 09:43:58    

Voici le .h
PS : La surcharge du constructeur fonctionne...
 

Code :
  1. //
  2. // IUT de Nice / Departement informatique / Module APO-C++
  3. // Annee 2009_2010 - Package _Maths
  4. //
  5. // Classe FractionG : modelisation du corps ZxZ
  6. //
  7. // Edition A      : TD_4
  8. //    Version 2.0.0   : version initiale
  9. //   
  10. // Auteur : C. Mus & S. Funel
  11. //
  12. #include <stdio.h>
  13. #include <math.h>
  16. #ifndef _Object_
  17. #include "T:\_Archives\Object\Object.h"
  18. #endif
  20. #ifndef _Archive_
  21. #include "T:\_Archives\Archive\Archive.h"
  22. #endif
  24. #ifndef _Archive_
  25. #include "T:\_Archives\_Archives\_Archives.h"
  26. #endif
  29. #define _FractionG_
  31. // Fonctions publiques de servitudes
  32. //
  33. int PGCD (int, int);
  34. int PPCM (int, int);
  36. template <class G> class FractionG {
  38. private :
  39. int m_numerateur;
  40. int m_denominateur;
  42. void  reduire ();
  44. public :
  45. // ------ Constructeurs
  46. //
  47. FractionG () {m_numerateur= 0; m_denominateur=1;}
  48. FractionG(int, int);
  49. FractionG(int);
  50. FractionG(const FractionG& );
  52. // ------ Accesseurs  
  53. //
  54. inline bool ok()  const {return (m_denominateur==0 ? false : true);}
  55. inline bool nok() const {return !ok();}
  57. inline int numerateur()   const {return m_numerateur;}
  58. inline int denominateur() const {return m_denominateur;}
  60. // ------ Operateurs
  61. //
  62. FractionG& operator =(const FractionG& );
  63. FractionG& operator =(int);
  65. FractionG* operator +(const FractionG& );
  66. FractionG* operator +(int);
  67. FractionG& operator +=(const FractionG& );
  68. FractionG& operator +=(int);
  70. FractionG* operator -(const FractionG& );
  71. FractionG* operator -(int);
  72. FractionG& operator -=(const FractionG& );
  73. FractionG& operator -=(int);
  75. FractionG* operator *(const FractionG& );
  76. FractionG* operator *(int);
  77. FractionG& operator *=(const FractionG& );
  78. FractionG& operator *=(int);
  80. FractionG* operator /(const FractionG& );
  81. FractionG* operator /(int);
  82. FractionG& operator /=(const FractionG& );
  83. FractionG& operator /=(int);
  85. bool operator ==(const FractionG& );
  86. bool operator ==(int);
  88. bool operator !=(const FractionG& );
  89. bool operator !=(int);
  91. bool operator <(const FractionG& );
  92. bool operator <(int);
  94. bool operator <=(const FractionG& );
  95. bool operator <=(int);
  97. bool operator >(const FractionG& );
  98. bool operator >(int);
  100. bool operator >=(const FractionG& );
  101. bool operator >=(int);
  103. // ------ Services
  104. //
  105. char* toString() const;
  107. };

Reply

Marsh Posté le 09-12-2009 à 09:59:41    

Ce que Joel dit, c'est que sauf cas particulier (voir http://www.bourguet.org/v2/cpplang/export.pdf), on est force de voir la definition des templates quand on les utilise.  Donc on place la definition dans le .hpp -- directement ou indirectement, j'ai tendance a la mettre un .tpp qui est inclus dans le .hpp, tout comme mes definitions inline sont parfois dans un .ipp.
 
Seconde remarque, utiliser des chemins absolus dans les includes est une mauvaise idee.  Utilise des chemins relatifs (et avec / comme separateur, ca marche sous Windows comme sous Unix) et indique les racines ou chercher a ton compilateur.


---------------
The truth is rarely pure and never simple (Oscar Wilde)
Reply

Marsh Posté le 09-12-2009 à 10:03:10    

Pour les chemins c'est normal, on travail tous sur la même base T:
Mais c'est vrai que tu as raison !
 
Sinon je ne vois pas où il y a un problème, pour le faire je me suis calquer sur la MatriceG de fraction qui fonctionne très bien (sauf la persistance).
 
Edit : Le chemins sont absolue dans certain étant donnée qu'on utilise le versioning. j'avais zapper !


Message édité par Philip Masse le 09-12-2009 à 10:52:32
Reply

Marsh Posté le 09-12-2009 à 10:24:08    

Alors, on y va y aller tres lentement:
 
Bien:

Code :
  1. // template.hpp
  3. template<class T> struct foo
  4. {
  5.    void bar() { /* some code; */ }
  6. };


 
PAS Bien:

Code :
  1. // template.hpp
  3. template<class T> struct foo
  4. {
  5.    void bar();
  6. };


 

Code :
  1. //template.cpp
  3. #include "template.hpp"
  5. template<class T> void foo<T>::bar() { /* some code; */ }


 

Reply

Marsh Posté le 09-12-2009 à 10:48:38    

heuuu :s

Reply

Sujets relatifs:

Leave a Replay

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