[LANGAGE C] Somme, multiplication de deux matrices

[Kreg]

Bonjour,

Je commence le C et je souhaiterais créer une fonction qui permette de faire la somme de deux matrices ou de multiplier deux matrices (j'aurais donc ces matrices en tant qu'argument de ma fonction)
Ensuite, j'appellerais cette fonction dans mon main.
Toutefois, je souhaiterais que ma fonction s'adapte à toute dimension de ma matrice (je ne voudrais pas recréer une fonction somme pour toutes dimensions différentes de mes matrices de départs).

Comment puis je m'y prendre ?
J'ai essayé de définir une fonction comme suivant : void somme (int mat1[N1][N2],int mat2[N3][N4]) avec Ni la taille des matrices effectives mais cela n'a pas l'air de fonctionner.

Merci de votre aide !
-----

[Jack]

il faudrait plutôt partir sur des pointeurs avec une déclaration de fonction telle que celle-ci:
int** somme(int ** mat1, int** mat2, int nbLignes, int nbColonnes);

[Kreg]

Bonjour Jack,

Merci pour votre réponse.
J'ai décidé de partir sur les pointeurs mais c'est une nouvelle notion pour moi (et donc, j'ai encore du mal à maitriser...).
Aussi, j'ai simplifié le problème dans un premier temps (en faisant la somme de deux tableaux et non de deux matrices) car au final, un tableau est une matrice particulière.

Mon code fonctionne mais ne fait pas la bonne somme :

  
#include <stdio.h>
#include <stdlib.h>
 
 
int *somme(int *tab1, int *tab2, int nbColonnes){
    int j;
    int *tab3;
    tab3=(int*) malloc (nbColonnes*sizeof(int));
 
    for(j=0;j<nbColonnes;j++){
 
             tab3[j]=tab1[j]+tab2[j];
    }
    return (tab3);
}
 
int main()
{
 
    int tab1={5,2};
    int tab2={4,17};
    int *tab3;
    tab3=somme(&tab1,&tab2,2);
 
    printf(" %d \n",tab3[0]);
    printf(" %d \n",tab3[1]);
 
} 
  

A l'exécution, j'obtiens : tab3=[9,7}.
Le premier composant est bon mais pas le suivant. Pourquoi à votre avis ?

Deuxième question, j'ai lu sur un site que (grossièrement) :
*p <=> valeur
p <=> adresse

Donc lorsque j'écris "return tab3", je renvoie en fait l'adresse où se trouve la première case de tab3 ?

Merci de votre aide

[Jack]

Tu n'as pas d'erreur de compilation?
Il faut effectuer quelques modifications:
int tab1[]={5,2};
int tab2[]={4,17};

tab3=somme(tab1,tab2,2); // pas de symbole &

Donc lorsque j'écris "return tab3", je renvoie en fait l'adresse où se trouve la première case de tab3 ?

oui.

Il faut normalement restituer la mémoire prise par le malloc avec l'instruction free

A+

[A voir en vidéo sur Futura]

[polo974]

Pour les matrices de taille variable, il est plus simple de déclarer une structure avec comme variables:
int nblig;
int nbcol;
double *data; // pointeur sur une zone continue contenant toutes les données

et une caisses de fonctions pour travailler avec...
lors de la création faire une allocation de la mémoire data=malloc(sizeof(double)*nbl ig*nbcol)
et pour taper la data de la 3ème ligne, 5ème colonne faire data[ nbcol * 3 + 5 ]

à la fin (quand la matrice n'est plus utilisée) ne pas oublier de faire un free(data)...

comme ça plus de tableaux à 2 dimensions qui posent tant de problèmes en C...

[Kreg]

Bonjour,

Merci, cela fonctionne parfaitement !
Je m'occuperais plus tard de la fonction libération
Pourquoi pas de symbole & ? Je pensais qu'il fallait faire passer l'adresse dans ce genre de fonction.

Non, pas eu d'erreur de compilation (mais ma console a plantée).

J'ai essayé de passer au niveau des matrices en reprenant le même schéma que les tableaux.
Toutefois la console plante également :

 #include <stdio.h>
#include <stdlib.h>
 
 
int **somme(int **mat1,int **mat2,int nbLignes,int nbColonnes){
 
    int i,j;
    int **mat3;
    mat3= (int**)malloc(nbLignes*sizeof(int*));
    for (i = 0; i < nbLignes; i++){
            mat3[i] = (int*)malloc(nbColonnes * sizeof(int));
    }
 
    for(i=0;i<nbLignes;i++){
        for(j=0;j<nbColonnes;j++){
            mat3[nbLignes][nbColonnes]=mat1[nbLignes][nbColonnes]+mat2[nbLignes][nbColonnes];
        }
    }
    return mat3;
}
 
int main()
{
 
    int m1[2][2]={{5,4},{2,7}};
    int m2[2][2]={{2,9},{4,1}};
    int **m3;
 
    m3=somme(m1,m2,2,2);
    return 0;
 
} 
  

Où est mon erreur ?

Merci Polo974 pour vos conseils, je vais voir aussi votre méthode.

Bonne journée !

[Jack]

Pourquoi pas de symbole & ? Je pensais qu'il fallait faire passer l'adresse dans ce genre de fonction.

Parce qu'en écrivant
int tab1[]={5,2};
tab1 représente déjà l'adresse du début de la mémoire allouée aux données du tableau.

Non, pas eu d'erreur de compilation

C'est inquiètant. Quel est le compilateur?

[danyvio]

Non, pas eu d'erreur de compilation (mais ma console a plantée).

!

Loi de Murphy (enfin une parmi d'autres) : si cela fonctionne, c'est qu'il y a une erreur cachée

[albanxiii]

Bonjour,

lors de la création faire une allocation de la mémoire data=malloc(sizeof(double)*nbl ig*nbcol)
et pour taper la data de la 3ème ligne, 5ème colonne faire data[ nbcol * 3 + 5 ]

à la fin (quand la matrice n'est plus utilisée) ne pas oublier de faire un free(data)...

Et tant qu'à faire, après le

data = malloc( ... );

rajouter un

if ( data == NULL )
{ 
  /* bouh, la vilaine erreur, faire quelque chose pour le dire à l'utilisateur */
  exit(1);
}

@+

[Kreg]

Bonjour,

C'est inquiètant. Quel est le compilateur?

Je suis sous Code blocks

Je pense faire la méthode de polo974 ce week end, j'aurais un peu plus de temps.

Quelqu'un a réussi toutefois à trouver l'erreur dans le code pour les matrices.
J'ai simplement transposé le cas des tableaux pour une matrice pourtant... même raisonnement, même méthode.


Merci

[Jack]

Je suis sous Code blocks

Code::Blocks est un IDE et peut utiliser différents compilateurs. En principe Code::Blocks renvoie dans une fenêtre les résultats de la compilation.

Je pense faire la méthode de polo974 ce week end, j'aurais un peu plus de temps.

C'est sûrement la solution la plus élégante.

Quelqu'un a réussi toutefois à trouver l'erreur dans le code pour les matrices.

Le compilateur a besoin de connaitre le nombre de colonnes. De nombreux articles expliquant ceci existent en ligne.

[polo974]

Bonjour,
...
Je pense faire la méthode de polo974 ce week end, j'aurais un peu plus de temps.
...

Merci

J'ai fais "mieux" (lire ma signature ...)
avec ce qui suit, on peut utiliser le notation m->data[lig][col] ou bien m->data[0][lig*nbcol + col] (selon le besoin)...
ça prend un peu plus de place (le tableau de pointeurs en plus), mais c'est plus convivial...

#include <stdio.h>
#include <stdlib.h>

FILE* fmsg;

typedef struct {
    int nblig;
    int nbcol;
    double ** data;
    } mat, *ptmat;

ptmat new_mat(int nl, int nc)
{
    ptmat mem;
    double * lig;
    int i;
    i = sizeof(mat) + nl * (sizeof(void *) + nc * sizeof(double));
    fprintf(fmsg, "malloc(%d)\n", i);
    if(mem = malloc(i))
    {
        mem->nblig = nl;
        mem->nbcol = nc;
        mem->data = (double **)(mem + 1);    // skip structure
        lig = (double *) (mem->data + nl);    // skip tableau de pointeurs
        for (i = 0; i < nl; i++)
        {
            mem->data[i] = lig;
            lig += nc;
        }
    }
    else
    {
        fprintf(fmsg, "argh malloc ! ! !\n");
    }
    return mem;
}


int main (int argc, char *argv[])
{
    ptmat m1, m2;
    void *p, *q;
    int i,d;

    double m;
    double*x;

    fmsg=fdopen(2,"a");

    fprintf(fmsg, "sizeof(int) = %d\n", (int) sizeof(int));
    fprintf(fmsg, "sizeof(void *) = %d\n", (int) sizeof(void *));
    fprintf(fmsg, "sizeof(mat) = %d\n", (int) sizeof(mat));

    if (NULL == (m1 = new_mat(3, 3)))    //    creation d'une matrice 3 * 3
    {
        fprintf(fmsg, "OUPS, plus de place pour ma matrice ! ! !\n");
        exit(1);
    }

        // blabla verif init matrice
    fprintf(fmsg, "matrice de %d lignes, %d colonnes\n", m1->nblig, m1->nbcol);

    p=(void *) m1;
    q=(void *) m1->data;
    d = q-p;
    fprintf(fmsg, "offset data %d\n", d);
    for (i = 0; i< m1->nblig; i++)
    {
        q=(void *) m1->data[i];
        d = q-p;
        fprintf(fmsg, "offset data[%d] %d\n", i, d);
    }
        // fin blabla 

        // remplissage de la matrice en [lig][col]
    m1->data[0][0] = 0.;
    m1->data[0][1] = 0.1;
    m1->data[0][2] = 0.2;

    m1->data[1][0] = 1.;
    m1->data[1][1] = 1.1;
    m1->data[1][2] = 1.2;

    m1->data[2][0] = 2.;
    m1->data[2][1] = 2.1;
    m1->data[2][2] = 2.2;

        // lecture de la matrice en [0][i] (ou [0][lig*nbcol + col])
    x = m1->data[0];
    for (i = 0; i < 3*3; i++)
        fprintf(fmsg, "x[%d] %f\n", i, x[i]);


    return 0;
}