Matrice et operateurs

Version imprimable

onjour!

Voilà, j'essaye de créer une classe de matrices avec la surcharge d'opérateurs mais je dois tester si les matrices sont d'un ordre compatible

Par exemple, je ne peux additionner que des matrices de même ordre (n x m)
ou quand je multiplie deux matrices entre-elles, l'ordre des matrices doit être (n x m) * (m x p)
Il faut donc que je teste avant d'effectuer le calcul et ceci se fait... pas bien! Voici la fonction que j'utilise :
Code:

1 2 3 4 5 6 7 8 9 Matrice Matrice::operator+(const Matrice &matrice) { Matrice resultat = *this; for (int i = 0; i < m_y; ++i) for (int j = 0; j < m_x; ++j) resultat.m_matrice[i][j] += matrice.m_matrice[i][j]; return resultat; }
Le problème dans ce code c'est qu'on renvoie un objet de la classe matrice dans tous les cas, alors qu'on ne devrait rien renvoyer si le calcul est impossible... Hum

Comment faire?
merci

09/10/2007, 18h38
zais_ethael

Ben tu testes les longueurs et largeurs et tu lances une exception si ça ne s'accorde pas.

Citation:
Envoyé par dev0077
onjour!

Voilà, j'essaye de créer une classe de matrices avec la surcharge d'opérateurs mais je dois tester si les matrices sont d'un ordre compatible

Par exemple, je ne peux additionner que des matrices de même ordre (n x m)
ou quand je multiplie deux matrices entre-elles, l'ordre des matrices doit être (n x m) * (m x p)
Il faut donc que je teste avant d'effectuer le calcul et ceci se fait... pas bien! Voici la fonction que j'utilise :
Code:

1 2 3 4 5 6 7 8 9 Matrice Matrice::operator+(const Matrice &matrice) { Matrice resultat = *this; for (int i = 0; i < m_y; ++i) for (int j = 0; j < m_x; ++j) resultat.m_matrice[i][j] += matrice.m_matrice[i][j]; return resultat; }
Le problème dans ce code c'est qu'on renvoie un objet de la classe matrice dans tous les cas, alors qu'on ne devrait rien renvoyer si le calcul est impossible... Hum

Comment faire?
merci
Si tu ne veut pas faire des exeptions. tu devrait definir un booleen qui indique que le resultat est faux.
mat = mat2 + mat3;

Code:

if (mat.Error() ) std::cout<<"erreur de calcul"<<std::endl;

Juste pour ajouter une raison d'utiliser un tableau 1D au lieu de 2D, est que tu peut faire des opérations comme cela avec un seul for et donc de manière plus rapide.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 class matrice { . . . std::vector<int> matrice; } Matrice Matrice::operator+(const Matrice &matrice) { Matrice resultat = *this; for (int i = 0; i <resultat.matrice.size(); ++i) resultat.m_matrice[i] += matrice.m_matrice[i]; return resultat; }

Le mieux est encore de l'interdire à la compilation à coup de templates...

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
template<T,l,h> Matrice : private Matrice_Impl<T>
{
   public:
         inline Matrice() : Matrice_Impl(l,h) {}
 
         inline Matrice(const Matrice<T,l,h>& mat) : Matrice_Impl(l,h)
         { set(mat,l,h); }
 
         inline Matrice<l,h>& operator=(const Matrice<T,l,h>& mat)
         { set(mat,l,h); return *this; }
 
 
         inline Matrice<T,l,h>& operator+=(const Matrice<T,l,h>& mat)
         { add(mat,l,h); return *this; }
         inline Matrice<T,l,h> operator+(const Matrice<T,l,h>& mat) const
         { Matrice<T,l,h> ret(*this); ret += mat; return ret; }
 
         ...
};
 
template<T,w,hw,h> Matrice<T,w,h> operator* (const Matrice<T,w,wh>& left, const Matrice<T,wh,h>& right)
{ ... }