Multiplication de matrices : "violation d'accès"

Bonjour,
Débutant en C++, je fais un programme permettant d'effectuer des opérations de matrices, et je dois surcharger l'opérateur * pour permettre de multiplier deux matrices entre elles.
la classe de la matrice CMatrice contient 3 données membres :
nombre de lignes int m_nNlignes, nombre de colonnes int m_nNcolonnes, tableau 2D double** m_pTab.

Au moment d'exécuter, si m_nNlignes != m_nNcolonnes, le programme plante, en évoquant une violation d'accès...
Quelqu'un saurait-il d'où viens le problème?
Je précise que le programme ne rencontre pas de problème avec les autres fonctions (addition de matrices, multiplication par un scalaire, surcharge << et >>, etc.)

Merci d'avance! Si vous avez besoin d'autres morceaux de code je vous les fournirais bien sûr.

ma surcharge dans Matrice.cpp :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

CMatrice CMatrice::operator*(const CMatrice& mat) { CMatrice resultat; if (m_nNcolonnes == mat.m_nNlignes) { CMatrice resultat(*this);   resultat.m_nNcolonnes = mat.m_nNcolonnes; resultat.m_nNlignes = m_nNlignes; int m = m_nNlignes;     for (int i = 0; i < resultat.m_nNlignes; i++) { for (int j = 0; j < resultat.m_nNcolonnes; j++) { resultat.m_pTab[i][j] = 0; for (int k = 0; k < m; k++) resultat.m_pTab[i][j] = resultat.m_pTab[i][j] + m_pTab[i][k] * mat.m_pTab[k][j]; } } } else cout << "Produit impossible : dimensions incompatibles" << endl;   return resultat; }

---

Je précise juste que le programme crash arrivé à la ligne suivante :
resultat.m_pTab[i][j] = resultat.m_pTab[i][j] + m_pTab[i][k] * mat.m_pTab[k][j]

Hello,

Hum, ça sent l'inversion de lignes / colonnes

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

int m = m_nNlignes;   for (int i = 0; i < resultat.m_nNlignes; i++) { for (int j = 0; j < resultat.m_nNcolonnes; j++) { resultat.m_pTab[i][j] = 0; for (int k = 0; k < m; k++) // [l][c] [l][c] [l][l] [l][c] resultat.m_pTab[i][j] = resultat.m_pTab[i][j] + m_pTab[i][k] * mat.m_pTab[k][j]; } }

---

A priori, pour m_pTab[i][k], tu utilises 2 indices de ligne. Si nbLignes != nbColonnes alors ya un problème.

Oui le problème est assez simple:
1. mettons que this (la matrice à gauche de l'opérateur) fasse 3 lignes et 2 colonnes
2. tu crées une matrice de résultat qui contient 3 lignes et 2 colonnes par:

Code:

---

CMatrice resultat(*this);

---

3. tu changes le décompte des colonnes, mais pas leur nombre (la mémoire qui leur est allouée) par:

Code:

---

resultat.m_nNcolonnes = mat.m_nNcolonnes;

---

4. si tu multiplies avec une matrice de 2 lignes et 3 colonnes, lorsque tu calcules le produit matriciel par:

Code:

---

resultat.m_pTab[i][j] = resultat.m_pTab[i][j] + m_pTab[i][k] * mat.m_pTab[k][j];

---

5. tu écris dans des colonnes qui n'ont pas été allouées et tu obtiens un bon vieux crash

Moralité:
- a minima, crée une nouvelle matrice aux dimensions de la matrice de résultat (this->lignes*mat.colonnes)
- et mieux: l'opérateur de multiplication devrait être en dehors de la classe matrice:

Code:

---

CMatrice operator*(const CMatrice& lhs, const CMatrice& rhs);

---

et utiliser des accesseurs sûrs qui préviennent les violations d'accès.

Bonsoir.

Attention à la ligne 2 et 4 il y a deux déclarations de la variable resultat, la seconde du bloc if (m_nNcolonnes == mat.m_nNlignes) masque la première.
Le resultat renvoyé n'est donc pas le second, mais le premier, celui initialisé par défaut.

Je suis prêt à parier que double **m_pTab est un pointeur pas ou mal initialisé.
Peux tu nous montrer le code de ton(tes) constructeur(s) ?

Ah, et :tagcode:

Edit: grillé :lefou:

Bonjour,

Merci pour vos réponses à mon problème! J'ai suivis vos conseils, cependant j'ai toujours la même erreur.... Je précise que je dois surcharger * (instruction du prof :?).

Je vous donne donc mon programme modifié :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

CMatrice CMatrice::operator*(const CMatrice& mat) { CMatrice resultat; if (m_nNcolonnes == mat.m_nNlignes) {   resultat.set_Nc(mat.m_nNlignes); //set_Nc : assesseur initialisant m_nNcolonnes; resultat.set_Nl(m_nNlignes); //set_Nl : assesseur initialisant m_nNlignes; int m = resultat.m_nNlignes;   //reservation de la memoire //get_Nl() retourne m_nNlignes, get_Nc() retourne m_nNcolonnes   resultat.m_pTab = new double*[resultat.get_Nl()]; for (int i = 0; i < resultat.get_Nl(); i++) { resultat.m_pTab[i] = new double[resultat.get_Nc()]; }     for (int i = 0; i < resultat.get_Nl(); i++) { for (int j = 0; j < resultat.get_Nc(); j++) { resultat.m_pTab[i][j] = 0; for (int k = 0; k < m; k++) resultat.m_pTab[i][j] = resultat.m_pTab[i][j] + m_pTab[i][k] * mat.m_pTab[k][j]; } } } else cout << "Produit impossible : dimensions incompatibles" << endl;   return resultat; }

---

Voici la déclaration de mes assesseurs en inline dans mon .h :

Code:

---

1 2 3 4

int get_Nl(){ return m_nNlignes; } int get_Nc(){ return m_nNcolonnes; } void set_Nl(int L){ m_nNlignes = L; } void set_Nc(int C){ m_nNcolonnes = C; }

---

Et à votre demande, mon constructeur sans paramètres :

Code:

---

1 2 3 4

CMatrice::CMatrice() : m_nNlignes(0), m_nNcolonnes(0), m_pTab(NULL) { }

---

EDIT Désolé pour la balise, je ne savais pas comment faire ^^ Maintenant c'est bon!

La racine du mal, c'est que tu fais faire trop de choses à ta fonction de multiplication.

Tu devrais avoir d'autres constructeurs pour ta matrice, en particulier un qui prenne comme argument le nombre de lignes et de colonnes et qui se charge de l'allocation de la mémoire (sur une seule ligne, faisons simple):

Code:

---

CMatrice (unsigned l, unsigned c) : lignes(l), colonnes(c), pmat(new double[l*c]) {}

---

Encore mieux, ta classe CMatrice devrait contenir un std::vector qui se charge pour toi de la gestion de la mémoire.

Code:

---

CMatrice (unsigned l, unsigned c) : lignes(l), colonnes(c) { vecmat.resize(l*c, 0); } // vecteur de taille l*c initialisé à 0

---

Et un accesseur at(unsigned, unsigned):

Code:

---

1 2	double& CMatrice::at(unsigned i, unsigned j) { return vecmat[i*colonnes+j); } double CMatrice::at(unsigned i, unsigned j) const { return vecmat[i*colonnes+j); } // n'oublions pas la version const

---

Donc:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

CMatrice CMatrice::operator*(const CMatrice& mat) { // on se débarrasse d'abord du cas particulier, cela rend le code plus lisible if (this->colonnes != mat.lignes) return CMatrice(); // le mieux serait plutôt une exception je pense CMatrice resultat(this->lignes, mat.colonnes); for (int i = 0; i < resultat.lignes; i++) { for (int j = 0; j < resultat.colonnes; j++) { for (int k = 0; k < mat.lignes; k++) { resultat.at(i,j) += this->at(i,k) * mat.at(k,j); } } } return resultat; }

---

Après bien sûr c'est à polir, lignes et colonnes devraient être des fonctions, etc... Et surtout l'opérateur de multiplication devrait être extérieur à la classe, pas sa méthode.

Merci pour vos solutions!
Je vais tenter cela.