Forum |  HardWare.fr | News | Articles | PC | S'identifier | S'inscrire | Shop Recherche
1725 connectés 

  FORUM HardWare.fr
  Programmation
  C++

  Probleme(s) sur les Template

 
 


 Mot :   Pseudo :  
 
Bas de page
Auteur Sujet :

Probleme(s) sur les Template

n°1948532
Philip Mas​se
Chocapiiic
Posté le 08-12-2009 à 19:25:01  profilanswer
 

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
mood
Publicité
Posté le 08-12-2009 à 19:25:01  profilanswer
 

n°1948540
Un Program​meur
Posté le 08-12-2009 à 20:03:22  profilanswer
 

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


---------------
The truth is rarely pure and never simple (Oscar Wilde)
n°1948542
Philip Mas​se
Chocapiiic
Posté le 08-12-2009 à 20:13:58  profilanswer
 

Petite erreur, merci :)
Corrigé !

n°1948564
Joel F
Real men use unique_ptr
Posté le 08-12-2009 à 22:21:12  profilanswer
 

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
n°1948608
Philip Mas​se
Chocapiiic
Posté le 09-12-2009 à 09:43:58  profilanswer
 

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. };

n°1948616
Un Program​meur
Posté le 09-12-2009 à 09:59:41  profilanswer
 

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)
n°1948621
Philip Mas​se
Chocapiiic
Posté le 09-12-2009 à 10:03:10  profilanswer
 

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
n°1948625
Joel F
Real men use unique_ptr
Posté le 09-12-2009 à 10:24:08  profilanswer
 

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; */ }


 

n°1948640
Philip Mas​se
Chocapiiic
Posté le 09-12-2009 à 10:48:38  profilanswer
 

heuuu :s


Aller à :
Ajouter une réponse
  FORUM HardWare.fr
  Programmation
  C++

  Probleme(s) sur les Template

 

Sujets relatifs
Problème Template matching matlabProbleme de compilation avec les template
problème sur un templateProblème template template [RESOLU]
Problème Coppermine : "Template error"[Problème] - Template affichage :??:
[resolu] [perl] problème "lib text::template" suite migration serverProblème avec un template: balise boddy déséquilibrée
[c++] template -> sujet d'examen 2004 (problème de compréhension)probleme de template avec une datagrid
Plus de sujets relatifs à : Probleme(s) sur les Template

Forum MesDiscussions.Net, Version 2010.2
(c) 2000-2011 Doctissimo
Page générée en 0.198 secondes

Copyright © 1997-2022 Hardware.fr SARL (Signaler un contenu illicite / Données personnelles) / Groupe LDLC / Shop HFR