MULTIPLICATION MATRICES , Source N°10321

Information sur la source

Catégorie :Application Niveau : Débutant Date de création : 23/01/2003 Date de mise à jour : 23/01/2003 09:37:06 Vu : 3 726

Auteur : loraine9999

Ecrire un message privé

Note :

8,00 / 10

1
2
3
4
5
6
7
8
9
10

Commentaire sur cette source (9)

Ajouter un commentaire et/ou une note

Description

multiplication de 2 matrices

Source

#pragma hdrstop
#include <conio.h>
#include <iomanip.h>
#include <iostream.h>
#include <stdlib.h>
//---------------------------------------------------------------------------
int **multiplieMatrice(int **matriceA, int colonnesA, int lignesA, int **matriceB, int colonnesB, int lignesB);
#pragma argsused
int main(int argc, char* argv[])
{
int lignes1;
int colonnes1 ;
int lignes2 ;
int colonnes2 ;
int **m1 ;
int **m2 ;
int **m3 ;
int i, j ;
do
{
cout << "1ere matrice : " << endl ;
cout << "combien de lignes ? " ;
cin >> lignes1 ;
cout << endl << "combien de colonnes ? " ;
cin >> colonnes1 ;
cout << endl << "2eme matrice : " << endl ;
cout << "combien de lignes ? " ;
cin >> lignes2 ;
cout << endl << "combien de colonnes ? " ;
cin >> colonnes2 ;
if (colonnes1!= lignes2)
cout << "erreur, les matrices ne peuvent pas etre multipliees!!! " << endl ;
}
while (colonnes1 != lignes2) ;
// si les matrices sont ok : colonnes1 == lignes2
m1 = (int**)malloc(lignes1 * sizeof(int*)) ;
m2 = (int**)malloc(lignes2 * sizeof(int*)) ;
if (!m1)
{
free(m1) ;
cout << endl << "erreur d'alloc 1ere matrice!!! " ;
return NULL ;
}
for (i=0 ; i<lignes1 ; i++)
{
m1[i] = (int*)malloc(colonnes1 * sizeof(int)) ;
if (!m1[i])
{
free(m1) ;
cout << endl << "erreur d'alloc lignes!!! " ;
return NULL ;
}
}
if (!m2)
{
free(m2) ;
cout << endl << "erreur d'alloc 1ere matrice!!! " ;
return NULL ;
}
for (i=0 ; i<lignes2 ; i++)
{
m2[i] = (int*)malloc(colonnes2 * sizeof(int)) ;
if (!m2[i])
{
free(m2) ;
cout << endl << "erreur d'alloc lignes!!! " ;
return NULL ;
}
}
cout << endl << "1ere matrice : " << endl ;
for (i=0 ; i<lignes1 ; i++)
{
for (j=0 ; j<colonnes1 ; j++)
{
cout << endl << "nombre en place " << i << " ; " << j << " ? " ;
cin >> m1[i][j] ;
}
}
cout << endl ;
// affichage 1ere matrice
for (i=0 ; i<lignes1 ; i++)
{
for (j=0 ; j<colonnes1 ; j++)
{
cout << setw(3) << m1[i][j] ;
}
cout << endl ;
}
cout << endl << "2eme matrice : " << endl ;
for (i=0 ; i<lignes2 ; i++)
{
for (j=0 ; j<colonnes2 ; j++)
{
cout << "nombre en place " << i << " ; " << j << " ? " ;
cin >> m2[i][j] ;
}
}
cout << endl ;
// affichage 2eme matrice
for (i=0 ; i<lignes2 ; i++)
{
for (j=0 ; j<colonnes2 ; j++)
cout << setw(3) << m2[i][j] ;
cout << endl ;
}
// multiplication des matrices
m3 = multiplieMatrice(m1, colonnes1, lignes1, m2, colonnes2, lignes2) ;
cout << endl << "Multiplication des matrices......" << endl ;
cout << endl << "Matrice Resultat : " << endl ;
for (i=0 ; i<lignes1 ; i++)
{
for (j=0 ; j<colonnes2 ; j++)
cout << setw(3) << m3[i][j] ;
cout << endl ;
}
free(m1) ;
free(m2) ;
free(m3) ;
cout << endl << endl << "appuyer sur une touche pour quitter..." ;
getch () ;
return 0 ;
}
//---------------------------------------------------------------------------
// fonction multiplication des 2 matrices
int **multiplieMatrice(int **matriceA, int colonnesA, int lignesA, int **matriceB, int colonnesB, int lignesB)
{
int **matriceR ;
int i, j, k ;
matriceR = (int**)malloc(lignesA * sizeof(int*)) ;
if (!matriceR)
{
free(matriceR) ;
cout << endl << "erreur d'alloc matrice reponse !!! " ;
return NULL ;
}
for (i=0 ; i<lignesA ; i++)
{
matriceR[i] = (int*)malloc(colonnesB * sizeof(int)) ;
if (!matriceR[i])
{
free(matriceR) ;
cout << endl << "erreur d'alloc lignes!!! " ;
return NULL ;
}
}
for (i=0 ; i<lignesA; i++)
for (j=0 ; j<colonnesB; j++)
{
matriceR[i][j] = 0 ;
for (k=0 ; k<colonnesA ; k++)
matriceR[i][j] += matriceA[i][k] * matriceB[k][j] ;
}
return matriceR ;
}

#pragma hdrstop

#include <conio.h>
#include <iomanip.h>
#include <iostream.h>
#include <stdlib.h>

//---------------------------------------------------------------------------

int **multiplieMatrice(int **matriceA, int colonnesA, int lignesA, int **matriceB, int colonnesB, int lignesB);

#pragma argsused
int main(int argc, char* argv[])
    {
    int lignes1;
    int colonnes1 ;
    int lignes2 ;
    int colonnes2 ;
    int **m1 ;
    int **m2 ;
    int **m3 ;
    int i, j ;

    do
        {
        cout << "1ere matrice : " << endl ;
        cout << "combien de lignes ? " ;
        cin >> lignes1 ;

        cout << endl << "combien de colonnes ? " ;
        cin >> colonnes1 ;

        cout << endl << "2eme matrice : " << endl ;
        cout << "combien de lignes ? " ;
        cin >> lignes2 ;

        cout << endl << "combien de colonnes ? " ;
        cin >> colonnes2 ;

        if (colonnes1!= lignes2)
                cout << "erreur, les matrices ne peuvent pas etre multipliees!!! " << endl ;

        }
    while (colonnes1 != lignes2) ;

    // si les matrices sont ok : colonnes1 == lignes2

    m1 = (int**)malloc(lignes1 * sizeof(int*)) ;
    m2 = (int**)malloc(lignes2 * sizeof(int*)) ;

    if (!m1)
        {
        free(m1) ;
        cout << endl << "erreur d'alloc 1ere matrice!!! " ;
        return NULL ;
        }

    for (i=0 ; i<lignes1 ; i++)
        {
        m1[i] = (int*)malloc(colonnes1 * sizeof(int)) ;

        if (!m1[i])
            {
            free(m1) ;
            cout << endl << "erreur d'alloc lignes!!! " ;
            return NULL ;
            }
        }

     if (!m2)
        {
        free(m2) ;
        cout << endl << "erreur d'alloc 1ere matrice!!! " ;
        return NULL ;
        }

     for (i=0 ; i<lignes2 ; i++)
        {
        m2[i] = (int*)malloc(colonnes2 * sizeof(int)) ;

        if (!m2[i])
                {
                free(m2) ;
                cout << endl << "erreur d'alloc lignes!!! " ;
                return NULL ;
                }
        }


    cout << endl << "1ere matrice : " << endl ;

    for (i=0 ; i<lignes1 ; i++)
        {
        for (j=0 ; j<colonnes1 ; j++)
                {
                cout << endl << "nombre en place " << i << " ; " << j << " ? " ;
                cin >> m1[i][j] ;
                }
        }

    cout << endl ;

    // affichage 1ere matrice
    for (i=0 ; i<lignes1 ; i++)
         {
         for (j=0 ; j<colonnes1 ; j++)
                {
                cout << setw(3) << m1[i][j] ;
                }
         cout << endl ;
         }

    cout << endl << "2eme matrice : " << endl ;

    for (i=0 ; i<lignes2 ; i++)
        {
        for (j=0 ; j<colonnes2 ; j++)
                {
                cout << "nombre en place " << i << " ; " << j << " ? " ;
                cin >> m2[i][j] ;
                }
        }

    cout << endl ;

    // affichage 2eme matrice
    for (i=0 ; i<lignes2 ; i++)
         {
         for (j=0 ; j<colonnes2 ; j++)
                cout << setw(3) << m2[i][j] ;
         cout << endl ;
         }

    // multiplication des matrices

    m3 = multiplieMatrice(m1, colonnes1, lignes1, m2, colonnes2, lignes2) ;
    
    cout << endl << "Multiplication des matrices......" << endl ;
    cout << endl << "Matrice Resultat : " << endl ;

    for (i=0 ; i<lignes1 ; i++)
        {
        for (j=0 ; j<colonnes2 ; j++)
            cout << setw(3) << m3[i][j] ;
        cout << endl ;
        }

    free(m1) ;
    free(m2) ;
    free(m3) ;

    cout << endl << endl << "appuyer sur une touche pour quitter..." ;
    getch () ;
    return 0 ;

    }
//---------------------------------------------------------------------------

// fonction multiplication des 2 matrices

int **multiplieMatrice(int **matriceA, int colonnesA, int lignesA, int **matriceB, int colonnesB, int lignesB)
    {
    int **matriceR ;
    int i, j, k ;

    matriceR = (int**)malloc(lignesA * sizeof(int*)) ;

    if (!matriceR)
        {
        free(matriceR) ;
        cout << endl << "erreur d'alloc matrice reponse !!! " ;
        return NULL ;
        }

    for (i=0 ; i<lignesA ; i++)
        {
        matriceR[i] = (int*)malloc(colonnesB * sizeof(int)) ;

        if (!matriceR[i])
            {
            free(matriceR) ;
            cout << endl << "erreur d'alloc lignes!!! " ;
            return NULL ;
            }
        }

    for (i=0 ; i<lignesA; i++)
        for (j=0 ; j<colonnesB; j++)
            {
            matriceR[i][j] = 0 ;

            for (k=0 ; k<colonnesA ; k++)
                matriceR[i][j] += matriceA[i][k] * matriceB[k][j] ;
            }
    return matriceR ;
    }

Sources du même auteur

Toutes les sources de loraine9999

Sources de la même categorie

Toutes les sources de la catégorie Application

Commentaires

Commentaire de bouba le 23/01/2003 09:49:54

C'est quoi ton compilateur ?
Commentaire de Kaid le 23/01/2003 10:24:08

- Pourquoi mélanger du C (malloc() & free()) avec du C++ (cout) ?

- Sinon dans le code suivant, si l'allocation mémoire se passe mal, tu libères un pointeur NULL:

        if (!m1)  // m1=NULL
        {
        free(m1) ; // free(NULL);
        cout << endl << "erreur d'alloc 1ere matrice!!! " ;
        return NULL ;
        }
Commentaire de Kaid le 23/01/2003 10:27:33

- Et justement dans le cas précédement cité, tu retournes NULL dans la fonction main(), ca marche, mais c'est pas très logique (d'autant que tu retournes aussi 0 en cas de succès).
Commentaire de vieuxLion le 23/01/2003 11:13:04

C'est bien présenté, pour rendre encore plus joli, tu pourrais rappeler la multiplication :
[1 0]      [1]      [1]
         x        =
[0 1]      [2]      [2]

et puis utilise le new[]/delete[]
Pour plus de réutilisation met tout ca dans une classe Matrice et dote la de constructeurs, d'une méthode d'impression,...-)
Commentaire de Kaid le 23/01/2003 11:31:34

Pour finir (oui ca fait beaucoup), tu as des fuites mémoire:

1- m1 = (int**)malloc(lignes1 * sizeof(int*)) ;
2- m1[INDEX] = (int*)malloc(colonnes1 * sizeof(int)) ;
3- L'étape qu'il te manque -> libérer les tableaux allouer par 2
4- free(m1);

for(int i=0;i<colonnes1;i++)
free(m1[i]);

free(m1);
Commentaire de nEUrOne le 23/01/2003 12:48:51

en tou cas, c'est bien indenté (emacs il me semble)
Commentaire de loraine9999 le 23/01/2003 16:01:26

ouoauauouaaaaaaaaaaah merci pour tous ces bons conseils ;-)

mon compilateur c'est borland builder C++ version6
on mélange du C et du C++...
Commentaire de GoldenEye le 23/01/2003 16:27:10

C'est pas récursif clap clap clap :-))
Fais attention au mélange C/C++, bcp de puristes te le reprocheront et ça diminue la lisibilité du code voire même la portabibilité. Comme le dis Kaid révise bien les allocations mémoires. Tout ce qui est alloué à un moment doit être désalloué. Pour t'aider tu peux tout simplement utiliser un compteur d'allocation et un compteur de désallocation qui te permettront de savoir où tu en est.
Commentaire de Galett le 27/01/2003 15:27:39

tiens un compteur de désallocation, c'est pas bête, voilà une info qui pourrait me servir :o)