probleme d'heritage

probleme d'heritage - C++ - Programmation

Marsh Posté le 31-01-2003 à 12:47:05    

je ne comprend pas où est mon erreur??
les trois premieres lignes du main s'executent sans prob, donc la class Matrix ne pose pas de prob par contre la ligne suivante cause une erreure, je ne comprend pas l'erreur (a mon avis ça doit être un truc dont je suis pas aucourant appropos des héritages...)  
 
voici le code: (c'est le constructeur de copie de la class BASE ki couille)

Code :
  1. #include<iostream.h>
  3. template <class Type>
  4. class Matrix{
  5. public:
  6. Type** M;
  7. unsigned n;
  9. Matrix(unsigned =0);
  10. Matrix(const Matrix& Mat) { Copy(Mat); }
  11. ~Matrix() { Erase(); }
  12. void Copy(const Matrix&);
  13. void Erase();
  14. Matrix& operator= (const Matrix&);
  15. Matrix& operator*= (const Matrix&);
  16. void Display();
  17. };
  19. template<class Type>
  20. Matrix<Type>::Matrix(unsigned x){
  21. n=x;
  22. M=new unsigned* [n];
  23. for(unsigned i=0; i<n; i++)
  24.  M[i]= new Type[n];
  25. for(unsigned j=0; j<n; j++)
  26.  for(unsigned k=0; k<n; k++){
  27.   if(j!=k) M[j][k]=0;
  28.   else M[j][k]=1;
  29.  }
  31. }
  33. template<class Type>
  34. void Matrix<Type>::Copy(const Matrix& Mat){
  35. n=Mat.n;
  36. M=new unsigned* [n];
  37. for(unsigned h=0; h<n; h++)
  38.  M[h]= new Type[n];
  39. for(unsigned i=0; i<n; i++)
  40.  for(unsigned j=0; j<n; j++)
  41.   M[i][j]=Mat.M[i][j];
  43. }
  45. template<class Type>
  46. void Matrix<Type>::Erase(){
  47. for(unsigned i=0; i<n; i++)
  48.  delete[] M[i];
  49. delete[] M;
  50. M=NULL;
  51. n=0;
  52. }
  54. template<class Type>
  55. Matrix<Type>& Matrix<Type>::operator= (const Matrix& Mat){
  56. Erase();
  57. Copy(Mat);
  58. return *this;
  59. }
  61. template<class Type>
  62. Matrix<Type>& Matrix<Type>::operator*= (const Matrix& Mat){
  63. if(n!=Mat.n)
  64.  cerr<<"ERROR : Matrix<Type>& Matrix<Type>::operator*= (const Matrix& Mat)";
  65. else{
  66.  Matrix<Type> tmp(n);
  67.  for(unsigned i=0; i<n; i++)
  68.   for(unsigned j=0; j<n; j++){
  69.    tmp.M[i][j]=0;
  70.    for(unsigned k=0; k<n; k++)
  71.     tmp.M[i][j]+=M[i][k]*M[k][j];
  72.   }
  73.  Copy(tmp);
  74. }
  76. return *this;
  77. }
  79. template<class Type>
  80. void Matrix<Type>::Display(){
  81. for(unsigned i=0; i<n; i++){
  82.  for(unsigned j=0; j<n; j++)
  83.   cout<<"\t"<<M[i][j];
  84. }
  85. }
  88. /************************************************************************************************
  89. /*****************************************BASE<TYPE>**********************************************/
  91. template<class Type>
  92. class BASE: public Matrix<Type>{
  93. public:
  94. Type* RGB;
  95. BASE(unsigned n=0, Type* rgb=NULL): RGB(rgb), Matrix<Type>(n) {}
  96. BASE(unsigned , Type R, Type G, Type B): RGB(new Type[3]), Matrix<Type>(n)  
  97.        {RGB[0]=R; RGB[1]=G; RGB[2]=B;}
  98. BASE(const BASE& B) { Copy(B); }  
  99. void Copy(const BASE& B) {  
  100.            Copy(B.M);   
  101.            if(B.RGB){  
  102.               if(!RGB) RGB=new Type[3];
  103.                 RGB[0]=B.RGB[0];
  104.                 RGB[1]=B.RGB[1];  
  105.                 RGB[2]=B.RGB[2];
  106.            }  
  107.        }
  108. ~BASE() { if(RGB) delete[] RGB; }
  109. };
  111. /*************************************************************************************************/
  113. void main(){
  114. Matrix<unsigned> M1(10);
  115. Matrix<unsigned> M2(M1);
  117. BASE<unsigned> B1(10);   
  118. // BASE<unsigned> B2(B1);    cause une erreur!*
  119. }


*error C2664: 'Copy' : cannot convert parameter 1 from 'unsigned int **const  ' to 'const class BASE<unsigned int> &'
        Reason: cannot convert from 'unsigned int **const  ' to 'const class BASE<unsigned int>'
 
J'ai pourtant surchargé mon opérateur de copie dans la class Matrix :??:


Message édité par peak le 31-01-2003 à 12:54:16
Reply

Marsh Posté le 31-01-2003 à 12:47:05   

Reply

Marsh Posté le 31-01-2003 à 12:55:42    

Code :
  1. BASE(const BASE& B) : Matrix ((const Matrix&)B) { Copy(B); } 
  2.      void Copy(const BASE& B) { if(B.RGB){ if(!RGB) RGB=new Type[3]; RGB[0]=B.RGB[0];


 
t'appelles le constructeur pas copie de ta base et ensuite tu t'occupes de la partie concernant ta classe fille.
En + tu essaies d'utiliser un Copy prenant un  Type** mais t'en as pas

Reply

Marsh Posté le 31-01-2003 à 13:04:00    

Code :
  1. void Copy(const BASE& B) Copy(B.M); //ici j'appel comme même bien la foncton Copy de matrix non?
  2. BASE(const BASE& B) : Matrix ((const Matrix&)B) { Copy(B); } //je svai pas ke ça marchait comme ça  ;)


 
 :jap:

Reply

Marsh Posté le 31-01-2003 à 13:08:52    

yep!! ça marche!!
MERCI
 
(j'ai juste encore apparement un tit prob a la destruction mais ça devrai etre arrangable)

Reply

Marsh Posté le 31-01-2003 à 13:30:13    

Code :
  1. ~BASE() { if(RGB) delete[] RGB; }


pk est ce ke mon destrusteur cause une violoation d'acces memoire??

Reply

Marsh Posté le 31-01-2003 à 13:36:45    

Avec un RGB=NULL ds les constructeurs ca evitera de delete quand il existe pas

Reply

Marsh Posté le 31-01-2003 à 13:39:52    

;)  
exact!!
Merci

Reply

Marsh Posté le 31-01-2003 à 19:20:48    

imaginons ke j'ai une BASE B et une Matrix Mat je voudrai faire B*=Mat de manier a ce ke juste "la partie" Matrix de B soit modifié  
Y'a-t-il moyen avec l'operator tel k'il est défini dans mon code??

Reply

Marsh Posté le 31-01-2003 à 19:29:13    

je vois pas trop l'utilité de Copy? un constructeur de recopie et un operator= ca fait pas l'affaire?

Reply

Marsh Posté le 31-01-2003 à 19:33:48    

ouais, c'est vrai ke c'est pas vraipment necessaire; c'est juste ke je trouvai pratique de fair une seul fonction ke j'appel ensuite dans les 2autres...

Reply

Marsh Posté le 31-01-2003 à 19:33:48   

Reply

Marsh Posté le 31-01-2003 à 19:43:22    

ben sémantiquement, c'est le role du constructeur par recopie de te donner une copie...., apres tout gravite autour de lui (affectation, swap, etc)

Reply

Marsh Posté le 31-01-2003 à 23:14:18    

ouais, t'as sans doute raison mais c'est une habitude (en general je fait la même chose avec une fct Erase()), soit, ça reste un detail d'implementation.... je voudrait surtout savoir si je suis obligé de surcharger mon operateur *= pour faire B*=Mat ou si Denis Ritchie a comme d'hab pensé à tout??

Reply

Marsh Posté le 01-02-2003 à 06:00:12    

Peak a écrit a écrit :

imaginons ke j'ai une BASE B et une Matrix Mat je voudrai faire B*=Mat de manier a ce ke juste "la partie" Matrix de B soit modifié  
Y'a-t-il moyen avec l'operator tel k'il est défini dans mon code??


Code :
  1. template <class Type>
  2. class BASE{
  3. Matrix<Type> Mat_;
  4. public:
  5. const BASE& operator *=(const Matrix<Type>& Mat){
  6.  B.Mat_*= Mat;
  7.  return *this;
  8. }
  9. };


Denis Ritchie s'occipait du C.
C'est Bjarne Stroustrup qu'il faut remercier (ou haïr) pour le C++.


Message édité par Musaran le 01-02-2003 à 06:00:59

---------------
Bricocheap: Montage de ventilo sur paté de mastic silicone
Reply

Marsh Posté le 01-02-2003 à 12:57:16    

mais dans mon code, BASE hérite de Matrix donc je n'ai pas de "nom" (Mat_) à la Matrix ki constitue ma BASE.
Dans mon code B.M est pointeur de pointeur pas Matrix.
Bon j'avoue ke un heritage étai peu être pas necessaire dans mon cas mais bon j'avai jamais vraiment utilisé d'heritage et me suis dis ke ça me ferai pas de mal....
En fait c'est d'autant plus marrant ke sans definir aucun operateur dans Base je peux fair B1*=B2 et c'est unikement ça partie Matrix ki en est modifié; j'ai provisoirement resolu le prob comme ça mais j'aimerai quand même évité de declaré systématikement des BASE alors ke je fait de multiples operations sur des Matrix ke je fini seulement par combiner à une BASE.


Message édité par peak le 01-02-2003 à 12:59:09
Reply

Marsh Posté le 02-02-2003 à 04:36:10    

Citation :

mais j'aimerai quand même évité de declaré systématikement des BASE alors ke je fait de multiples operations sur des Matrix ke je fini seulement par combiner à une BASE.

Qu'est-ce qui t'en empêche ?


---------------
Bricocheap: Montage de ventilo sur paté de mastic silicone
Reply

Marsh Posté le 02-02-2003 à 19:15:48    

ke justement je n'arrive pas a faire B*=Mat

Reply

Marsh Posté le 03-02-2003 à 09:41:02    

Code :
  1. Matrix<unsigned> M1(10);
  2. BASE<unsigned> B1(10);
  4. B1*=M1;

Chez moi ça marche©.
 
Montre le code et le message d'erreur.
 
À tout hasard:

Code :
  1. template<class Type>
  2. class BASE: public Matrix<Type>{
  3. public:
  4. using Matrix<Type>::operator *=;


---------------
Bricocheap: Montage de ventilo sur paté de mastic silicone
Reply

Marsh Posté le 03-02-2003 à 19:17:02    

:whistle:  
Alors là franchement désolé, je comprend vraiment pas se ke j'ai foutu?  :sweat:  :sweat:  :sweat:  
Je lis le post me dis "mais comment sa peux marcher chez lui et pas chez moi"  
Je retest chez moi et pouf ça marche j'y comprend vraiment rien.
Je suis absolument certain ke ça ne marchait pas y'a 3jours j'ai testé une dizaine de fois :heink:  
(j'ai sens doute changé un truc ke j'aurai pas du entre temps....)
 
mieux vaut ça ke le contraire :D  
 
Merci à toi ho MUSARAN!
et a tous les autres ki mon aidé dans ce topic!!
 
 :bounce:


Message édité par peak le 03-02-2003 à 19:18:04
Reply

Sujets relatifs:

Leave a Replay

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