Discussion :

[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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[zais_ethael]

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

[yan]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[nicroman]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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)
{ ... }