Donc tout est dans le titre, je dois créer une matrice de taille m*n en utilisant une matrice de type double **matrice.

Je sais faire le programme pour une matrice sans pointeur, et avec un simple pointeur, mais double pointeur comme cela, je ne sais pas. 

Pouvez vous m'aidez svp.

Voila ce que j'ai fait sans utiliser de pointeur. 

#include <stdio.h>
#include <stdlib.h>
#define MAX 100

typedef double matrice[MAX][MAX];

void saisie_matrice(matrice mat, int m, int n){
     int i,j;
     for (i=0; i<m; i++){
         for (j=0; j<n; j++){
             printf("Saisir la valeur a mat[%d][%d] : ", i, j);
             scanf("%lf", &mat[i][j]);     
             printf("\n");         
         }
     }
}


void affiche_matrice(matrice mat, int m, int n){
     int i,j;
     for (i=0; i<m; i++){
         printf("\n");
         for (j=0; j<n ; j++){
             printf(" %10lf  ", mat[i][j]);
         }
     }
}


int main(int argc, char *argv[])
{
    
    matrice mat;
    int m, n;
    printf("Nombre colonne de la matrice : ");
    scanf("%d", &m);
    printf("\n");
    printf("Nombre de ligne de la matrice : ");
    scanf("%d", &n);
    printf("\n");
    saisie_matrice(mat, m, n);
    printf("\n\n\n");
    printf("AFFICHAGE MATRICE \n\n\n");
    affiche_matrice(mat, m, n);
    
  
  system("PAUSE");	
  return 0;
}

Salut,

Et si tu nous montrais plutôt la version où tu n'y arrives pas ?

N'oublie pas que tu as pleins de ressources à ta disposition : Google, FAQ, cours... dans lesquels quelque chose d'aussi simple a été abordé des millions de fois.

ben je peux pas te montrer ce que j'arrive pas si je n'y arrive pas ... -.-"
Sinon j'ai déjà fait un paquet de recherche, pas je comprend pas trop ce que j'ai trouvé.
bah ben je vais continuer de chercher alors ...

Comprends pas trop quoi ? Si tu ne nous fournis aucun élément pour t'aider, ça va être un peu dur

Alors si j'ai bien compris tu cherche à faire passer un tableau à deux dimension?

SI c'est bien ça tu dois considérer ton tableau à deux dimension comme si c'était un tableau à une dimension... De sorte de la première ligne de ton tableau à 2 dimensions soit le début de ton tableau à une dimension et la dernière la fin de ton tableau à une dimension.

-
Edité par Kréation 16 janvier 2014 à 8:50:49

Bon j'ai essayé de faire sa, mais sa ne fonctionne pas comme il faut, j'ai un mauvais affichage pls help.

#include <stdio.h>
#include <stdlib.h>
#define MAX 100

typedef double matrice[MAX][MAX];

void saisie_matrice(matrice mat, int m, int n){
     int i,j;
     for (i=0; i<m; i++){
         for (j=0; j<n; j++){
             printf("Saisir la valeur a mat[%d][%d] : ", i, j);
             scanf("%lf", &mat[i][j]);     
             printf("\n");         
         }
     }
}


void affiche_matrice(matrice mat, int m, int n){
     int i,j;
     for (i=0; i<m; i++){
         printf("\n");
         for (j=0; j<n ; j++){
             printf(" %10lf  ", mat[i][j]);
         }
     }
}

void saisie_matrice_pointeur(double **mat, int m, int n){
    int i, j;
    
   *mat = malloc(m * n * sizeof(double));
    for (i=0; i<m; i++){
        for (j=0; j<n; j++){
            printf("Saisir la valeur a mat[%d][%d] : ", i, j);
            scanf("%lf", &mat +i * m * n + j);
       //     printf("%lf", mat +i * m * n + j);
            printf("\n");
        }
    }
}

void affiche_matrice_pointeur(double **mat, int m, int n){
     int i, j;
     
  //   *mat = malloc(m * n * sizeof(double));
     for (i=0; i<m; i++){
        printf("\n");
        for (j=0; j<n; j++){
            printf(" %10lf  ", *(&mat +i * m * n + j));
        }
    }
}
int main(int argc, char *argv[])
{
    matrice mat;
    double *mat2;
    mat2=&mat[0][0];
    int m, n;
    printf("Nombre colonne de la matrice : ");
      scanf("%d", &m);
    printf("\n");
    printf("Nombre de ligne de la matrice : ");
      scanf("%d", &n);
    printf("\n");
  //  saisie_matrice(mat, m, n);
    saisie_matrice_pointeur(&mat2, m, n);
    printf("\n\n\n");
    printf("AFFICHAGE MATRICE \n\n\n");
 //   affiche_matrice(mat, m, n);
    affiche_matrice_pointeur(&mat2, m, n);
    
  
  system("PAUSE");	
  return 0;
}

Commence déjà par le début : L'allocation dynamique de mémoire

Si tu as essayé de faire ce dont je t'avais parlé c'est que je me suis mal exprimé tu utilise encore un double pointeur...

et tu fais de l'allocation mémoire derrière du coup je ne suis pas sur d'avoir compris ce que tu cherchais.

ça pourrai t'aider: http://c.developpez.com/faq/?page=tableaux#TABLEAUX_tableau_parametre

C'est bon j'ai réussi à réajuster mon code!! pour ceux par la suite qui seront intéressé le voici :

maintenant pour le mettre en fonction et procédure, la je ne sais pas comment faire.

peut être aurais vous une idée ? 

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

int main(int argc, char *argv[])
{
    // DECLARATION DES VARIABLES
    int i, j, m, n;
    double **matrice;
    
    // DECLARATION DE LA TAILLE DE LA MATRICE m * n
    printf("Nombre ligne de la matrice : ");
    scanf("%d", &m);
    printf("\n");
    printf("Nombre de colonne de la matrice : ");
    scanf("%d", &n);
    printf("\n");
    
    // CREATION DE m TALBEAU DE n ELEMENTS CHACUN
    matrice = (double **)malloc(m*sizeof(double *));
    for (i=0; i<m; i++){
        matrice[i]= (double *)malloc(n*sizeof(double));
    }
    
    //SAISIE DES ELEMENTS DE LA MATRICE
    printf("Enter les elements de la matrice\n"); 
    for (i=0; i<m; i++){
        for (j=0; j<n; j++){
        printf("Saisir la valeur de mat[%d][%d] : ", i, j);
        scanf("%lf", &matrice[i][j]);
        printf("\n");
        }
    }
    
    // AFFICHAGE DE LA MATRICE
    printf("\n===> Matrice  <===\n"); 
    for (i=0;i<m;i++){ 
        printf("\n"); 
        for(j=0;j<n;j++){ 
        printf("%10lf ", matrice[i][j]); 
        
        }
    }
    
    
  system("PAUSE");	
  return 0;
}

Me revoici, voila je me répond à moi tout seul, mais si sa peut aidé d'autre, voila ce que j'ai réussi à faire : 

#include <stdio.h>
#include <stdlib.h>
#define MAX 100

    void saisie_matrice(double **matrice, int m, int n){
        int i,j;
    
    //SAISIE DES ELEMENTS DE LA MATRICE
        printf("Enter les elements de la matrice\n"); 
        for (i=0; i<m; i++){
            for (j=0; j<n; j++){
            printf("Saisir la valeur de mat[%d][%d] : ", i, j);
            scanf("%lf", &matrice[i][j]);
            printf("\n");
            }
        }
    }

    void affiche_matrice(double **matrice, int m, int n){
        int i,j;
    // AFFICHAGE DE LA MATRICE        
        for (i=0;i<m;i++){ 
            printf("\n"); 
            for(j=0;j<n;j++){ 
                printf("%10lf ", matrice[i][j]); 
        
            }
        }
        printf("\n\n");
    }
            
    void addition_matrice(double **matrice1, double **matrice2, double **matrice3, int m3, int n3){
        int i,j;
    // ADDITION DE LA MATRICE    
        for (i=0; i<m3; i++){
            for (j=0; j<n3; j++){
                matrice3[i][j]=matrice1[i][j]+matrice2[i][j];
            }
        }
    }
    
    void produit_scalaire_matrice(double **matrice, double **matrice3, double scalaire, int m, int n){
        int i,j;
    // MULTIPLICATION DE LA MATRICE PAR UN SCALAIRE
        for (i=0; i<m; i++){
            for (j=0; j<n; j++){
                matrice3[i][j]=matrice[i][j]*scalaire;
            }
        }
    }
       
int main(int argc, char *argv[])
{
    // DECLARATION DES VARIABLES
    int i, j, m1, n1, m2, n2, m3, n3;
    double scalaire;
    double **matrice1;
    double **matrice2;
    double **matrice3;
  
    
    /*------------------------- MATRICE 1 -------------------------*/
    
    // DECLARATION DE LA TAILLE DE LA MATRICE m * n
    printf("Nombre ligne de la matrice 1: ");
    scanf("%d", &m1);
    printf("\n");
    printf("Nombre de colonne de la matrice 1: ");
    scanf("%d", &n1);
    printf("\n");    
    // CREATION DE m TALBEAU DE n ELEMENTS CHACUN pour la matrice 1
    matrice1 = (double **)malloc(m1*sizeof(double *));
    for (i=0; i<m1; i++){
        matrice1[i]= (double *)malloc(n1*sizeof(double));
    }    
    // APPELLE FONCTION SAISIE MATRICE 
    saisie_matrice(matrice1, m1, n1);    
    // APPELLE FONCTION AFFICHE MATRICE 7
    printf("\n===> Matrice 1 <===\n"); 
    affiche_matrice(matrice1, m1, n1);
    
    
    /*------------------------- MATRICE 2 -------------------------*/
    
    // DECLARATION DE LA TAILLE DE LA MATRICE m * n
    printf("Nombre ligne de la matrice 2: ");
    scanf("%d", &m2);
    printf("\n");
    printf("Nombre de colonne de la matrice 2: ");
    scanf("%d", &n2);
    printf("\n");    
    // CREATION DE m TALBEAU DE n ELEMENTS CHACUN pour la matrice 1
    matrice2 = (double **)malloc(m2*sizeof(double *));
    for (i=0; i<m2; i++){
        matrice2[i]= (double *)malloc(n2*sizeof(double));
    }    
    // APPELLE FONCTION SAISIE MATRICE 
    saisie_matrice(matrice2, m2, n2);    
    // APPELLE FONCTION AFFICHE MATRICE 
    printf("\n===> Matrice 2 <===\n"); 
    affiche_matrice(matrice2, m2, n2);
    
    
    
    /*------------------------- ADDITION MATRICE -------------------------*/       
    
    //VERIFICATION POUR L'ADDITION
    if ((m1 == m2) && (n1 == n2)){     
        n3=n1;
        m3=m1;    
    // CREATION DE m TALBEAU DE n ELEMENTS CHACUN pour la matrice 1
        matrice3 = (double **)malloc(m3*sizeof(double *));
        for (i=0; i<m3; i++){
            matrice3[i]= (double *)malloc(n3*sizeof(double));
        }        
    // APPELLE FONCTION ADDITION
        addition_matrice(matrice1, matrice2, matrice3, m3, n3);    
        }        
    // SI ADDITION IMPOSSIBLE    
        else{ 
            printf("Vous ne pouvez pas additionner les deux matrices\n");
        }        
    // APPELLE FONCTION AFFICHE MATRICE 
    printf("\n===> Matrice 3 <===\n"); 
    affiche_matrice(matrice3, m3, n3);
    
    
    
    /*------------------------- PRODUIT SCALAIRE MATRICE -------------------------*/
    
    n3=n1;
    m3=m1;
    // CREATION DE m TALBEAU DE n ELEMENTS CHACUN pour la matrice 1
    matrice3 = (double **)malloc(m3*sizeof(double *));
    for (i=0; i<m3; i++){
        matrice3[i]= (double *)malloc(n3*sizeof(double));
    }    
    // APPELLE FONCTION PRODUIT SCALAIRE
    printf("Quelle est le votre scalaire : ");
    scanf("%lf", &scalaire);
    printf("\n");
    produit_scalaire_matrice(matrice1, matrice3, scalaire, m1, n1);
    // APPELLE FONCTION AFFICHE
    printf("\n===> Matrice 3 <===\n"); 
    affiche_matrice(matrice3, m3, n3);
        
        
    
    
    
    
    
  system("PAUSE");	
  return 0;
}

Et merci kréation , je n'avais pas très bien compris ce dont tu parlais.

Je crois avoir mieux compris ce que tu voulais dire, en faite il faut faire un tableau a une dimension qui contiendra un autre tableau a une dimension dans chacune de ses cases ? 

Regarde ce que j'ai fais, c'est quelque chose comme cela que tu parlais ? 

Et j'ai un peu mieux compris le truc maintenant, mais il y a toujours quelque chose qui me bloque un peu. C'est cette partie

// CREATION DE m TALBEAU DE n ELEMENTS CHACUN pour la matrice 1
    matrice2 = (double **)malloc(m2*sizeof(double *));
    for (i=0; i<m2; i++){
        matrice2[i]= (double *)malloc(n2*sizeof(double));
    }  

Bah en fet je ne comprend pas encore comment bien utilisé le malloc et comment sa se fait que c'est un double * en haut et un double simple en bas.

et un (double **) en haut et un (double *) en bas.

Bien sur j'ai lu les cours pointeur, pointeur dynamique, malloc sizeof... mais je comprend toujours pas très bien

Quelqu'un pourrais me révéler la vérité peut-être, en évitant de me dire va lire les cours.

Si tu veux générer dynamiquement un tableau à deux dimension en C tu dois faire comme ça... Je ne connais pas d'autres méthodes.

Ensuite pour les gérer il faut que tu te représente la place qui est prise en mémoire --> tu alloue n cases en mémoire pour ta ligne 0 et tu fais ça pour chaque ligne donc en gérant par adresse ta case  &matrice[1][0] correspond à &matrice[0+n].

Tu vois un peu l'idée?

-
Edité par Kréation 17 janvier 2014 à 15:22:40

malloc renvoi une adresse, (l'adresse du bloc mémoire ou sera stocké ton tableau), et pour stocker une adresse, quel type de variables utilise t'on ? : un pointeur !

Les cases de tes tableaux devant stocker des doubles, il te faut donc des pointeurs sur double pour stocker leurs adresses !

Le tableau de pointeur sur tes tableaux de double lui contient les adresses de chaque tableau de double. c'est donc un tableau de pointeur sur double, il te faut donc un pointeur de pointeur sur double pour stocker l'adresse de ce tableau !

Kréation a écrit:

Ensuite pour les gérer il faut que tu te représente la place qui est prise en mémoire --> tu alloue n cases en mémoire pour ta ligne 0 et tu fais ça pour chaque ligne donc en gérant par adresse ta case  &matrice[1][0] correspond à &matrice[0+n].

Absolument FAUX!!

Déjà ce serait &matrice[0][0+n] qui correspondrait à&matrice[1][0] , matrice[0+n] dépasserait la taille du tableau => plantage garanti !

Puis, alloués de cette façon, les tableaux entre chaque matrice[i] ne sont absolument pas contigüs !!!

Seuls les matrice2[0][i] le sont.

Le premier malloc sert à allouer de l'espace pour un tableau de pointeurs sur double, et chacun de ces pointeurs va aller pointer vers chaque zone mémoire allouée dans la boucle. Et ces zones mémoire n'ont rien à voir entre-elles, elles ne sont pas contigües !

-
Edité par Squall31 17 janvier 2014 à 16:58:21

J'ai pourtant gérer un programme comme ça, enfin explique moi comment tu comprends le passage d'un tableau à 2 dimensions dans une fonction voir lien suivant: http://c.developpez.com/faq/?page=tableaux#TABLEAUX_tableau_parametre

Après je m'exprime peut être mal mais il est possible de gérer un tableau à 2 dimensions dans une fonction en faisant appel à son adresse et en l’incrémentant ...

Après c'est vrai qu'avec le malloc--> ça change du tableau 2 dimensions fixe du coup tu as raison pour un tableau dynamique.

Pour un tableau à deux dimension dynamique par ligne ça se suis mais les références des lignes se suivent aussi sauf erreur de ma pars? Du coup en incrémentant l'adresse des diverses références ça fonctionne?

-
Edité par Kréation 18 janvier 2014 à 1:08:28

    /*------------------------- MATRICE 1 -------------------------*/
     
    // DECLARATION DE LA TAILLE DE LA MATRICE m * n
    printf("Nombre ligne de la matrice 1: ");
    scanf("%d", &m1);
    printf("\n");
    printf("Nombre de colonne de la matrice 1: ");
    scanf("%d", &n1);
    printf("\n");   
    // CREATION DE m TALBEAU DE n ELEMENTS CHACUN pour la matrice 1
    matrice1 = (double **)malloc(m1*sizeof(double *));
    for (i=0; i<m1; i++){
        matrice1[i]= (double *)malloc(n1*sizeof(double));
    }   
    // APPELLE FONCTION SAISIE MATRICE
    saisie_matrice(matrice1, m1, n1);   
    // APPELLE FONCTION AFFICHE MATRICE 7
    printf("\n===> Matrice 1 <===\n");
    affiche_matrice(matrice1, m1, n1);
     
     
    /*------------------------- MATRICE 2 -------------------------*/
     
    // DECLARATION DE LA TAILLE DE LA MATRICE m * n
    printf("Nombre ligne de la matrice 2: ");
    scanf("%d", &m2);
    printf("\n");
    printf("Nombre de colonne de la matrice 2: ");
    scanf("%d", &n2);
    printf("\n");   
    // CREATION DE m TALBEAU DE n ELEMENTS CHACUN pour la matrice 1
    matrice2 = (double **)malloc(m2*sizeof(double *));
    for (i=0; i<m2; i++){
        matrice2[i]= (double *)malloc(n2*sizeof(double));
    }   
    // APPELLE FONCTION SAISIE MATRICE
    saisie_matrice(matrice2, m2, n2);   
    // APPELLE FONCTION AFFICHE MATRICE
    printf("\n===> Matrice 2 <===\n");
    affiche_matrice(matrice2, m2, n2);

Fais une boucle pour ça :

    int z; // z car i est déjà pris
     
    for (z = 0; z < 2; z++)
    {
      // DECLARATION DE LA TAILLE DE LA MATRICE m * n
      printf("Nombre ligne de la matrice %d: ", z + 1);
      scanf("%d", &m[z]);
      printf("\n");
      printf("Nombre de colonne de la matrice %d: ", z + 1);
      scanf("%d", &n[z]);
      printf("\n");   
      // CREATION DE m TALBEAU DE n ELEMENTS CHACUN pour la matrice 1
      matrice[z] = (double **)malloc(m[z]*sizeof(double *));
      for (i=0; i<m[z]; i++){
          matrice[z][i]= (double *)malloc(n[z]*sizeof(double));
      }   
      // APPELLE FONCTION SAISIE MATRICE
      saisie_matrice(matrice[z], m[z], n[z]);   
      // APPELLE FONCTION AFFICHE MATRICE 7
      printf("\n===> Matrice %d <===\n", z + 1);
      affiche_matrice(matrice[z], m[z], n[z]);
    }

ça compilera sûrement pas mais c'est à titre d'exemple. Tout se répète, alors pour les variables fais un tableau du nombre de matrices que tu veux, et boucle le tout, toujours avec le nombre de matrices. Tu peux mettre le 2 en dur si t'es sûr d'en avoir toujours deux mais je te conseille de faire une macro pour que ton code soit facilement maintenable. Il y aura une petite difficulté dans ce cas là cependant car tu vas devoir faire un tableau de double pointeur. Il y a une autre solution plus simple si tu utilises que deux matrices, c'est qu'à chaque fois que tu utilises une matrice, tu fais une condition en testant le z pour savoir laquelle utiliser, mais ce serait pas très propre et ça prendrait des lignes inutilement.

Pour ce code :

// CREATION DE m TALBEAU DE n ELEMENTS CHACUN pour la matrice 1
    matrice2 = (double **)malloc(m2*sizeof(double *));
    for (i=0; i<m2; i++){
        matrice2[i]= (double *)malloc(n2*sizeof(double));
    }

Il me semble que ceci serait plus lisible, et ferait la même chose (je ne test pas, si il y a un problème dis le moi je corrigerais) :

matrice = malloc(m * sizeof(double *));
for (i = 0; i < m; i++)
  matrice[i]= malloc(n * sizeof(double));

Il est inutile de caster avec (double **) et (double *), vu que caster c'est pour changer le type et que de base les variables sont déjà du même type...

Déjà une difficulté de moins, ensuite avec une bonne indentation et des espaces entre les opérateurs c'est plus lisible, non ?

Pour ce qui est du sizeof, c'est simple :

matrice est de type double **, c'est à dire un pointeur sur pointeur de double.

Dans le cas d'un simple pointeur, on ferait :

double *matrice;

matrice = malloc(sizeof(double) * 10);

malloc retourne l'adresse de la première case mémoire allouée, hors quand on écrit "matrice" et que cette variable est un pointeur, on affecte à ce pointeur l'adresse sur laquelle elle va pointer. Et elle va pointer sur des double, d'où le "double" dans le sizeof.

Donc dans le cas d'un double pointeur, ça donne :

double **matrice;

matrice = malloc(sizeof(double *) * 10);
matrice[0] = malloc(sizeof(double) * 2);
matrice[1] = malloc(sizeof(double) * 2);
matrice[2] = malloc(sizeof(double) * 2);
...
matrice[9] = malloc(sizeof(double) * 2);

On a ici la variable matrice, qui est de type pointeur sur pointeur de double.

On alloue donc le pointeur sur pointeur, ensuite on alloue tous les pointeurs de double.

Si c'est confus ou que t'as encore des questions je pourrais tenter de reformuler... Mais je ne peux que te conseiller de relire ou tester pour comprendre.

Edit : réexplication rapide du sizeof :

malloc sert à allouer les cases mémoires que t'aurais par exemple dans un tableau.

Les types prennent différentes tailles de mémoire, donc pour être sûr de pas se tromper et d'avoir un code portable sur toutes les machines et architectures, on utilise la fonction sizeof qui renvoie le nombre d'octets du type de la variable à allouer.

Pour remplacer un double tableau de double : double tableau[10][2]

On va utiliser un double pointeur de double : double **tableau;

Donc si tu regardes le code dessus, tu vois qu'on alloue 10 pointeurs de double, et qu'ensuite on alloue 2 double pour chaque pointeur de double alloué. ça nous donnera un tableau à deux dimensions, un premier pointeur qui nous permet d'accéder à dix pointeurs de double, et chaque pointeur de double nous permettra d'accéder à deux double.

-
Edité par Horner74 18 janvier 2014 à 3:43:28

Kréation : Il faudrait commencer par se caler sur la même longueur d'onde, comment tu alloues ton tableau 2D ? Comme effectué ici ou en linéaire ?

J'avais pensé avec un tableau fixe à la base en fait d'où mon erreur... Car j'ai fais un programme en C de cette façon il n'y a pas longtemps...

Mais maintenant avec une allocution dynamique on ne peut pas faire comme j'ai dis precedement... mais en envoyant l'adresse de chaque ligne à une fonction on devrait pouvoir le gérer... où alors créer une liste

-
Edité par Kréation 18 janvier 2014 à 22:03:18

Kréation a écrit:

mais en envoyant l'adresse de chaque ligne à une fonction on devrait pouvoir le gérer..

C'est ce qu'on peut faire tout naturellement en passant un pointeur double

double **matrice;

en même temps que ses deux dimensions.

matrice[i] représente chaque ligne et matrice[i][j] représente chaque valeur.

-
Edité par Squall31 19 janvier 2014 à 9:57:47

vraiment merci horner et à vous tous qui m'ont bien aidé pour mon projet, 

@korner j'ai bien retiré le cast et sa fonction nikel, merci de cette précision.
De plus, après plusieurs relecture et test, j'ai finalement vraiment compris le malloc et sizeof ainsi que le **double :DDDD.

De plus, maintenant, mon code fonction nikel, mais il y a vraiment quelque chose qui me chagrine c'est devoir utiliser  dans mon main 

// CREATION DE m TALBEAU DE n ELEMENTS CHACUN pour la matrice 1
  matrice[z] = (double **)malloc(m[z]*sizeof(double *));
  for (i=0; i<m[z]; i++){
      matrice[z][i]= (double *)malloc(n[z]*sizeof(double));
  }  

pour chaque matrice que je créer (multiplication car elle change de taille (mat1*mat2=mat3,<-- mat3 nouveau malloc) et je refais mon malloc a chaque fois ke je fais une opération (tranposé pareil, pas la mm taille).
Et donc je me disais es-ce que on peut faire un malloc dans une procédure avec la saisie ?
Perso, j'ai fais plusieurs test, mais j'ai l'impression que le tableau ne sors pas de ma procédure, tt se créer bien lorsque je met mon malloc ds ma procédure, mais ensuite kan je sors de ma procédure, et je fais apelle à ma procédure affichage, ben plus rien. aucune val ds mon tableau.
(a punez, j'ai sup ce que j'avais essayé de faire, mais avais vous une idée ? )

J'ai sa comme première question et une toute dernière.

J'ai effectué des affichages vers la commande, et vers un fichier.

seul problème mon affichage fichier n'est pas dans une procédure, et donc j'ai un gros paté de code dans mon main, es-ce possible de faire une procédure pour l'affichage dans un fichier? 
Merci ;) 

 voila un exemple de mon affichage fichier : 

// APPELLE FONCTION SAISIE MATRICE 
    saisie_matrice(matrice1, m1, n1);    
    // APPELLE FONCTION AFFICHE MATRICE 7
    printf("\n===> Matrice 1 <===\n"); 
    affiche_matrice(matrice1, m1, n1);
    printf("\n\n");
    fprintf(fichier, "\n===> Matrice 1 <===\n");
    for (i=0;i<m1;i++){ 
        fprintf(fichier,"\n"); 
            for(j=0;j<n1;j++){ 
                fprintf(fichier,"%10lf ", matrice1[i][j]);        
            }
    }

 
 ou encore sa : (vous voyez toute la place que sa prend =(

// CONDITION POUR ADDITION
    if ((m1 == m2) && (n1 == n2)){     
        n3=n1;
        m3=m1;    
    // CREATION DE m TALBEAU DE n ELEMENTS CHACUN pour la matrice 1
        matrice3 = malloc(m3*sizeof(double *));
        for (i=0; i<m3; i++){
            matrice3[i]= malloc(n3*sizeof(double));
        }        
    // APPELLE FONCTION ADDITION
        addition_matrice(matrice1, matrice2, matrice3, m3, n3);    
    // APPELLE FONCTION AFFICHE MATRICE 
        printf("\n===> Matrice 3 ADDITION MATRICE 1 + MATRICE 2 <===\n"); 
        affiche_matrice(matrice1, m1, n1);
        printf("  +  \n");
        affiche_matrice(matrice2, m2, n2);
        printf("  =  \n");
        affiche_matrice(matrice3, m3, n3);        
        printf("\n\n");
        
         fprintf(fichier, "\n===> Matrice 3 ADDITION MATRICE 1 + MATRICE 2 <===\n");
    for (i=0;i<m1;i++){ 
        fprintf(fichier,"\n"); 
            for(j=0;j<n1;j++){ 
                fprintf(fichier,"%10lf ", matrice1[i][j]);        
            }
    }
    fprintf(fichier,"  +  \n");
    for (i=0;i<m2;i++){ 
        fprintf(fichier,"\n"); 
            for(j=0;j<n2;j++){ 
                fprintf(fichier,"%10lf ", matrice2[i][j]);        
            }
    }
    fprintf(fichier,"  =  \n");
    for (i=0;i<m3;i++){ 
        fprintf(fichier,"\n"); 
            for(j=0;j<n3;j++){ 
                fprintf(fichier,"%10lf ", matrice3[i][j]);        
            }
    }
    fprintf(fichier,"\n\n");        
    // SI PAS POSSIBLE
        }else{ 
            printf("Vous ne pouvez pas additionner les deux matrices\n\n");
            fprintf(fichier,"Vous ne pouvez pas additionner les deux matrices\n\n");         
        } 

Oui tu peux tout à fait faire tes allocations dans une fonction. `Ton problème doit sûrement venir du fait que tu passes une matrice, et non un pointeur sur une matrice. Les paramètres en C étant passés par copie, tu modifies seulement la copie et non l'original

Tu peux aussi créer une fonction qui affiche ta matrice, histoire de ne par recopier les boucles et printf à chaque fois.

-
Edité par Squall31 20 janvier 2014 à 10:20:29

Je sais déjà ce que tu me dis Squall31 mais j'ai des difficultés pour faire de la gestion de double pointeur dans une fonction c'est pour ça que j'envoie rarement plus qu'un pointeur simple.

--> en plus mon interface code block ne s'arrete pas au breaking point alors pour debugger c'est magique

Ce n'est pas parce que tu éprouves des difficultés à faire quelque chose, qu'il lfaut 'éviter, au contraire entraine-toi pour être à l'aise avec

Pour Code::Blocks, assure-toi de bien être mode débug, et que la ligne s'exécute bien, condition vraie etc.

-
Edité par Squall31 20 janvier 2014 à 11:49:26

Oui, si tu as une portion de code qui se répète fait une fonction, et la plus générale possible pour que tu puisses la réutiliser un maximum.

Ainsi une fonction pour allouer une matrice, une fonction pour l'afficher, une fonction pour la libérer, éventuellement des fonctions pour faire des calculs entre matrice, et ton main ne comptera que 4/5 lignes à la fin.

Merci de partager si vous aviez le modele de rempliassage et affichage d'une matrice seulement avec des pointeurs.