Multiplication matrices de tailles inconnues

airstrik Messages postés 4 Statut Membre -  
Hxyp Messages postés 401 Date d'inscription   Statut Membre Dernière intervention   -
Bonjour,

Voila je sais déja faire une multiplication de matrice en C. Mon probleme c que je dois multiplier des matrices dont les tailles varient au fur et a mesure du programme et le compilateur refuse ca.
Par exemple si je définis une fonction du genre:
max = 4000;
Void Prodmat(double A[][], int nla, int nca, double B[][], int nlb, int ncb, double C[max][max])
Aprés débogage je reçois des erreurs. (Error: invalid use of array with unspecified bounds)

Ou si j'essaye aussi
Void Prodmat(double A[max][max], double B[max][max], double C[max][max], int nla, int nca, int nlb, int ncb)

La dans le programme principale si je prends par exemple A[4][5] j'obtiens une erreur du genre impossible de convertir double [*][4000] en double[*][5].

Je ne sais plus ou donner la tête. PS: need help et c urgent

1 réponse

  1. Hxyp Messages postés 401 Date d'inscription   Statut Membre Dernière intervention   54
     
    Bonjour,
    En utilisant des pointeurs ça peut être plus simple, exemple :
    #include <stdio.h>
    #include <stdlib.h>
    #include <assert.h>
    
    void prodmat(double **A,int ya,int xa,double **B,int yb,int xb){
        int i,j;
        printf("A :\n");
        for(i=0;i<ya;i++){
            for(j=0;j<xa;j++)
                printf("%f ",A[i][j]);
            printf("\n");
        }
        printf("B :\n");
        for(i=0;i<yb;i++){
            for(j=0;j<xb;j++)
                printf("%f ",B[i][j]);
            printf("\n");
        }
    }
    
    double **allocm(int y,int x){
        double **ptr; int i;
        ptr=malloc(sizeof(double*)*y);
        if(ptr){
            for(i=0;i<y;i++){
                ptr[i]=malloc(sizeof(double)*x);
                assert(ptr[i]);
            }
        }
        return ptr;
    }
    void addstuff(double **ptr,int y,int x){
        int i,j,c=1;
        for(i=0;i<y;i++)
            for(j=0;j<x;j++){
                ptr[i][j]=c;
                c++;
            }
    }
    
    int main(void)
      {
        double **A,**B;
        A=allocm(4,5);
        B=allocm(3,2);
        addstuff(A,4,5);
        addstuff(B,3,2);
        prodmat(A,4,5,B,3,2);
        return 0;
      }
    

    N'oubliez pas de faire le free qui va avec allocm

    Une autre idée qui simplifierait encore serait d'utiliser une structure par matrice et éviterait d'avoir à préciser leur taille en paramètre des fonctions :

    #include <stdio.h>
    #include <stdlib.h>
    #include <assert.h>
    
    typedef struct{
        double **m;
        int y,x;
    }matx;
    
    void prodmat(matx *mA,matx *mB){
        int i,j;
        printf("A :\n");
        for(i=0;i<mA->y;i++){
            for(j=0;j<mA->x;j++)
                printf("%f ",mA->m[i][j]);
            printf("\n");
        }
        printf("B :\n");
        for(i=0;i<mB->y;i++){
            for(j=0;j<mB->x;j++)
                printf("%f ",mB->m[i][j]);
            printf("\n");
        }
    }
    
    matx *allocm(int y,int x){
        matx *ptr; int i;
        ptr=malloc(sizeof(matx));
        assert(ptr);
        ptr->y=y,ptr->x=x;
        ptr->m=malloc(sizeof(double*)*ptr->y);
        assert(ptr->m);
        for(i=0;i<ptr->y;i++){
            ptr->m[i]=malloc(sizeof(double)*ptr->x);
            assert(ptr->m[i]);
        }
        return ptr;
    }
    void addstuff(matx *m){
        int i,j,c=1;
        for(i=0;i<m->y;i++)
            for(j=0;j<m->x;j++){
                m->m[i][j]=c;
                c++;
            }
    }
    
    int main(void)
      {
        matx *mA,*mB;
        mA=allocm(4,5);
        mB=allocm(3,2);
        addstuff(mA);
        addstuff(mB);
        prodmat(mA,mB);
        return 0;
      }
    

    n'ai pas fais le free là non plus
    0