probleme programme C

Version imprimable

bonjour,
j'ai un problème avec ce programme, je voudrais remplir une matrice et l'afficher.
est-ce que quelqu'un pourrait corriger ce code pour qu'il fonctionne, svp ?
merci.

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
35
36
37
38
39
 
#include <stdio.h>
#include <stdlib.h>
 
int a, b;
int i,j;     
 
int remplir_mat(int *l, int *c)
{
     int **mat;
     for(i=0;i<*l;i++)
     {for(j=0;j<*c;j++)
     {printf("ligne %d, colonne %d : ", i+1, j+1);
     scanf("%d", &mat[i][j]);
     }
     }
     return mat;
}
 
void affiche_mat(int **mat, int l, int c)
{
 
     for(i=0;i<l;i++){
     for(j=0;j<c;j++)
     { printf("%d ", &mat[i][j]);
     }
     printf("\n");
     }
}
 
int main()
{
    int mat[10][10];
    N=2;
    M=2;
     printf("%d %d", a, b);
    remplir_mat(&a, &b);
    affiche_mat(mat, a, b);
}

12/11/2007, 00h57
Emmanuel Delahaye

Citation:

Envoyé par space_56

j'ai un problème avec ce programme, je voudrais remplir une matrice et l'afficher.

Beaucoup de fautes dans ce code... Tu devrais déjà revoir comment on passe un tableau à 2 dimensions à une fonction :

http://emmanuel-delahaye.developpez.....htm#param_tab

Citation:

est-ce que quelqu'un pourrait corriger ce code pour qu'il fonctionne, svp ?

Euh, non. Ca, c'est ton boulot... Commence par supprimer ces globales inutiles et par bien configurer ton compilateur :

http://emmanuel-delahaye.developpez....tm#cfg_compilo
12/11/2007, 01h18
space_56

tu peux me dire où sont les erreurs de ligne, stp ?
dans ce code les tableaux sont-ils bien transmis ?
12/11/2007, 01h34
Emmanuel Delahaye

Citation:

Envoyé par space_56

tu peux me dire où sont les erreurs de ligne, stp ?
dans ce code les tableaux sont-ils bien transmis ?

Tu ne vois pas que int **mat n'a aucun sens ici ? Il faut utiliser ce que j'ai indiqué, c'est à dire int mat[10][10] ou int mat[][10] et ne pas oublier de passer les dimensions aux fonctions.
12/11/2007, 18h47
Nykoo

Je m'étais amusé à gérer des matrices avec un programme c. On m'avait aidé sur HFR. Je peux toujours poster le code auquel j'étais arrivé, ça pourra toujours aider. Mais je sais pas si c'est dans l'esprit du forum. Donc si ça peut t'aider space_56 ;)

je ne comprends pas, ça ne marche toujours pas.

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
35
36
37
38
39
40
41
42
 
#include <stdio.h>
#include <stdlib.h>
 
int N, M;
int i,j;     
 
int remplir_matrice(int *l, int *c)
{
     int mat[10][10];
     /*scanf("%d %d", l, c);
     printf("%d %d", *l, *c);*/
     //mat = (int**) malloc((*l) * sizeof(int*)); 
     for(i=0;i<*l;i++)
     {for(j=0;j<*c;j++)
     {printf("ligne %d, colonne %d : ", i+1, j+1);
     scanf("%d", &mat[i][j]);
     }
     }
     return mat;
}
 
void affiche_mat(int mat[][], int l, int c)
{
 
     for(i=0;i<l;i++){
     for(j=0;j<c;j++)
     { printf("%d ", 1);
     }
     printf("\n");
     }
}
 
int main()
{
    int mat[10][10];
    N=2;
    M=2;
    printf("%d %d", N, M);
    remplir_matrice(&N, &M);
    affiche_mat(mat, N, M);
}

12/11/2007, 19h05
Nykoo

Pourquoi tu déclares tes variables N,M,i,j en globale? Surtout i, j c'est bizzare.

Ta fonction remplir_matrice doit renvoyer un int alors que tu renvoies un pointeur mat. Il faut donc rajouter un *après le int du prototype de ta fonction pour lui indiquer qu'elle doit renvoyer un pointeur vers un int et non pas un int.

Pourquoi tu passes tes paramètres (N,M) par pointeurs?
12/11/2007, 19h18
Thierry Chappuis
Citation:

Envoyé par space_56

je ne comprends pas, ça ne marche toujours pas.

Parce que tu codes au hasard. Premièrement, tu devrais enlever tes globales. Puis, dans ta fonction remplir_matrice(), mat est tableau de 10 tableaux de 10 ints (ou plus simplement dit une matrice de 10 x 10 ints). Tu ne peux pas retourner mat comme ça, et pour deux raisons.
1. Le type de retour est faux! Ce n'est pas int, mais un pointeur sur un tableau de 10 ints. Ce qui nous donnerait le prototype suivant:
  Code:
  
  1 2 int (*(remplir_matrice(int *l, int *c)))[10];
  cryptique, non?
2. mat est un tableau local à ta fonction. La mémoire allouée est libérée dès la sortie de la fonction. Ainsi, l'adresse retournée par la fonction devient aussitôt invalide.
De plus, le prototype de affiche_mat() doit être:

Code:

void affiche_mat(int mat[][10], int l, int c);

où mat est de type pointeur sur tableau de 10 ints.

Thierry
12/11/2007, 19h22
Nykoo

Citation:

Envoyé par Thierry Chappuis

De plus, le prototype de affiche_mat() doit être:

Code:

void affiche_mat(int mat[][10], int l, int c);

où mat est de type pointeur sur tableau de 10 ints.

C'est obligatoire d'écrire mat[][10] dans le prototype? Il me semble que non?
12/11/2007, 19h24
Emmanuel Delahaye

Citation:

Envoyé par Nykoo

C'est obligatoire d'écrire mat[][10] dans le prototype? Il me semble que non?

Dans ce cas là (tableau statique), oui.

http://emmanuel-delahaye.developpez.....htm#param_tab
12/11/2007, 19h37
Nykoo

Citation:

Envoyé par Emmanuel Delahaye

Dans ce cas là (tableau statique), oui.

http://emmanuel-delahaye.developpez.....htm#param_tab

Dans ce cas statique on peut passer mat[] (ou *mat) en paramètre?

D'ailleurs je sais pas si c'est moi, mais je trouve la formulation confuse ici:

Citation:

Pour définir un paramètre de type pointeur sur un tableau à 2 dimensions, on serait tenté d'écrire type p[][], ce qui est une erreur de syntaxe. En effet, la notation [] est une notation abrégée de [TAILLE] point ou point virgule? dans les cas où cette taille est ignorée par le compilateur, c'est à dire lorsque la dimension concernée est la plus à gauche.

On pourrait penser que la notation [] est interprété comme [TAILLE] quand la taille est ignorée par le compilot.

Encore une fois très utile ce site!

Citation:

Envoyé par Nykoo

Ta fonction remplir_matrice doit renvoyer un int alors que tu renvoies un pointeur mat. Il faut donc rajouter un *après le int du prototype de ta fonction pour lui indiquer qu'elle doit renvoyer un pointeur vers un int et non pas un int.

Non, si le PO veut renvoyer mat, le type de retour devra être un pointeur sur tableau de 10 ints, comme mentionné plus haut. Mais la mémoire pour mat devra être allouée dynamiquement (entre autres possibilités).

Voici un code corrigé:

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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
#include <stdio.h>
#include <stdlib.h>
 
#define MAT_NB_LIGNES 3
#define MAT_NB_COLS 4
 
void clean(void)
{
    int c;
 
    while ((c =getc(stdin)) != '\n' && c != EOF)
    {
    }
}
 
/* -tc- la fonction appelante alloue la mémoire pour la matrice et passe son 
    adresse en arguments. */
void remplir_matrice(int mat[][MAT_NB_COLS], int l, int c)
{
    /* -tc- validation des arguments */
    if (mat != NULL && l > 0 && c > 0)
    {
        /* -tc- les indices de boucles peuvent être locaux a la fonction */
        int i, j;
        int rv;
 
        for (i = 0; i < l; i++)
        {
            for (j = 0; j < c; j++)
            {
                /* -tc- saisie securisee d'un entier */
                do
                {
                    printf("ligne %d, colonne %d : ", i+1, j+1);
                    /* -tc- forcer l'affichage de l'invite avec fflush() */
                    fflush(stdout);
                    /* -tc- il est deconseille d'utiliser scanf() pour toute saisie
                        non formatee. Toutefois, si on desires vraiment l'utiliser,
                        il faut au minimum tester sa valeur de retour et faire le
                        menage apres utilisation. */
                    rv = scanf("%d", &mat[i][j]);
                    clean();
                }
                while (rv != 1);
            }
        }
    }
}
 
void affiche_mat(int mat[][MAT_NB_COLS], int l, int c)
{
    if (mat != NULL && l > 0 && c > 0)
    {
        /* -tc- ne pas definir lkes indices de boucle en global */
        int i, j;
 
        for (i = 0; i < l; i++)
        {
            for (j = 0; j < c; j++)
            {
                printf("%3d ", mat[i][j]);
            }
            printf("\n");
        }
    }
}
 
int main(void)
{
    int mat[MAT_NB_LIGNES][MAT_NB_COLS] = {{0}};
 
    printf("Matrice %d x %d\n", MAT_NB_LIGNES, MAT_NB_COLS);
    remplir_matrice(mat, MAT_NB_LIGNES, MAT_NB_COLS);
 
    affiche_mat(mat, MAT_NB_LIGNES, MAT_NB_COLS);
 
    /* -tc- main() doit retourner , EXIT_SUCCESS ou EXIT_FAILURE */
    return 0;
}

Thierry

12/11/2007, 19h49
Emmanuel Delahaye

Citation:

Envoyé par Nykoo

Dans ce cas statique on peut passer mat[] (ou *mat) en paramètre?

Bah non. Il y a 2 dimensions... C'est théoriquement

Code:

f (int mat[M][N])

On peut néanmoins omettre la taille de gauche, car elle n'entre pas dans le calcul :

Code:

f (int mat[][N])

Citation:

D'ailleurs je sais pas si c'est moi, mais je trouve la formulation confuse ici:

C'est possible... En fait non. C'est bien la suite de la phrase.

Citation:

On pourrait penser que la notation [] est interprété comme [TAILLE] quand la taille est ignorée par le compilot.

J'ai écrit ça ? Ben c'est correct.
12/11/2007, 19h50
Thierry Chappuis
Citation:

Envoyé par Nykoo

Dans ce cas statique on peut passer mat[] (ou *mat) en paramètre?

Si mat était un simple tableau à une dimension, oui! Pour un tableau à dimensions, on doit utiliser:
Code:

1 2 void ma_fonction(int mat[][NB_COLONNES], size_t lignes);
qui est strictement équivalent à:

Code:

void ma_fonction(int (*mat)[NB_COLONNES], size_t lignes);

Comme pour les tableau à une dimension, tu utilises un pointeur sur le premier élément du tableau. Dans notre cas, le premier élément du tableau est un lui-même un tableau.

Thierry
12/11/2007, 21h29
Nykoo

Ah je viens de comprendre pour l'histoire mat[][TAILLE]. En fait j'étais convaincu que le but était de passer le tableau en paramètre par son pointeur et non pas de passer tout le tableau en paramètre.

Pour la confusion dans le texte c'était mois qui était confus dans ma tête.

Sinon c'est sympa pour l'exemple propre de programme.

il y a une erreur dans le programme, mais je ne vois pas comment la corriger ?

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
35
36
37
38
 
#include <stdio.h>
#include <stdlib.h>
 
void remplir_matrice(int mat[][10])
{
 
     int N, M;
     int i,j;     
     printf("taille de la matrice : \n");
     scanf("%d %d", &N, &M);
     for(i=0;i<N;i++)
     {for(j=0;j<M;j++)
     {printf("ligne %d, colonne %d : ", i+1, j+1);
     scanf("%d", &mat[i][j]);
     }
     }
 
}
 
void affiche_mat(int mat[][10], int l, int c)
{
    int i,j;     
     for(i=0;i<l;i++){
     for(j=0;j<c;j++)
     { printf("3%d ", mat[i][j]);
     }
     printf("\n");
     }
}
 
int main()
{
    int N, M;
    int mat[10][10]={0};
    remplir_matrice(mat);
    affiche_mat(mat, N, M);
}

en fait je n'arrive pas à transmettre la matrice dans affiche_mat, comment faire ?

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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
#include <stdio.h>
 
#define NB_ELEM(tab) (sizeof (tab))/(sizeof *(tab))
#define ROWS 10
#define COLS 10
 
void remplir_matrice(int mat[][COLS], size_t rows, size_t cols);
void affiche_mat(int const mat[][COLS], size_t rows, size_t cols);
 
int main(void)
{
   int mat[ROWS][COLS] = { 0 };
    remplir_matrice(mat, NB_ELEM(mat), NB_ELEM(*mat));
    affiche_mat(mat, NB_ELEM(mat), NB_ELEM(*mat));
    return 0;
}
 
void remplir_matrice(int mat[][COLS], size_t rows, size_t cols)
{ 
   if(mat != NULL)
   {
      for(size_t i = 0; i < rows; i++)
      {
         for(size_t j = 0; j < cols; j++)
         {
            int ret;
            do
            {
               printf("ligne %u, colonne %u : ", i+1, j+1);
               fflush(stdout);
               ret = scanf("%d", &mat[i][j]);
               scanf("%*[^\n]"),getchar();
            }
            while(ret != 1);
         }
      }
   }
}
 
void affiche_mat(int const mat[][COLS], size_t rows, size_t cols)
{
   if(mat != NULL)
   {
      for(size_t i = 0; i < rows; i++)
      {
         for(size_t j = 0; j < cols; j++)
         { 
            printf("%d ", mat[i][j]);
         }
         puts("");
      }
   }
}

Citation:

Envoyé par space_56

il y a une erreur dans le programme, mais je ne vois pas comment la corriger ?

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
35
36
37
38
 
#include <stdio.h>
#include <stdlib.h>
 
void remplir_matrice(int mat[][10])
{
 
     int N, M;
     int i,j;     
     printf("taille de la matrice : \n");
     scanf("%d %d", &N, &M);
     for(i=0;i<N;i++)
     {for(j=0;j<M;j++)
     {printf("ligne %d, colonne %d : ", i+1, j+1);
     scanf("%d", &mat[i][j]);
     }
     }
 
}
 
void affiche_mat(int mat[][10], int l, int c)
{
    int i,j;     
     for(i=0;i<l;i++){
     for(j=0;j<c;j++)
     { printf("3%d ", mat[i][j]);
     }
     printf("\n");
     }
}
 
int main()
{
    int N, M;
    int mat[10][10]={0};
    remplir_matrice(mat);
    affiche_mat(mat, N, M);
}

en fait je n'arrive pas à transmettre la matrice dans affiche_mat, comment faire ?

12/11/2007, 22h04
Emmanuel Delahaye

Citation:

Envoyé par Nykoo

Ah je viens de comprendre pour l'histoire mat[][TAILLE]. En fait j'étais convaincu que le but était de passer le tableau en paramètre par son pointeur et non pas de passer tout le tableau en paramètre.

Pour la confusion dans le texte c'était mois qui était confus dans ma tête.

Hélas, tu es toujours dans la confusion.

Le paramètre qui permet à une fonction d'accéder à un tableau est toujours un pointeur.

En 1D, on écrit (T est le type, p le pointeur et N le nombre d'éléments) :

f (T p[N]) ou f (T p[]) ou f (T *p)

N étant 'à gauche' (c'est pas frappant quand il n'y a qu'une dimension, OK), il peut être omis.

Le paramètre est une 'adresse de type T'.

Ce trois pointeurs sont strictement identiques, parce qu'on est dans le cadre d'un paramètre de fonction.

En 2 D, on écrit :

f (T p[N][M]) ou f (T p[][M]) ou f (T *p[M])

Les 3 notations sont identiques et le paramètre est une 'adresse de type tableau de M x T'. p est donc bien un pointeur.
12/11/2007, 22h11
space_56

quand je fais la fonction remplir_mat, est-ce que le tableau est-il toujours là en sortant de la fonction ?
12/11/2007, 22h30
Emmanuel Delahaye

Citation:

Envoyé par space_56

quand je fais la fonction remplir_mat, est-ce que le tableau est-il toujours là en sortant de la fonction ?

Le tableau il a été défini ailleurs. La fonction n'a que l'adresse... J'ai du mal à saisir la question...

Si les tableaux à 2 dimensions te posent problème, commence par t'exercer avec un tableau à une dimension... Il y a certains mécanismes qui sont identiques mais plus simples...
13/11/2007, 15h47
Thierry Chappuis
Citation:

Envoyé par Nykoo

Ah je viens de comprendre pour l'histoire mat[][TAILLE]. En fait j'étais convaincu que le but était de passer le tableau en paramètre par son pointeur et non pas de passer tout le tableau en paramètre.

On ne passe pas le tableau en paramètre, mat[][TAILLE] est un pointeur. Si tu fais le test dans ta fonction, tu verras que
Code:

1 2 sizeof mat
est égale à

Code:

sizeof (int (*)[TAILLE])

Thierry
13/11/2007, 15h52
Thierry Chappuis
Citation:

Envoyé par Emmanuel Delahaye

f (T p[N][M]) ou f (T p[][M]) ou f (T *p[M])

Les 3 notations sont identiques et le paramètre est une 'adresse de type tableau de M x T'. p est donc bien un pointeur.

Attention, ce n'est pas

Code:

f(T *p[M])

mais
Code:

1 2 f(T (*p)[M])
Les deux notations ne sont pas équivalentes. Dans le premier cas, T est de type pointeur sur pointeur sur T (T **). Dans le deuxième cas, p est de type pointeur sur un tableau de M éléments de type T.

En effet:
Code:

1 2 3 4 5 f(T *p[M]) /* ou */ f(T *p[]) /* ou */ f(T **p)
sont trois notations équivalentes différentes de:

Code:

f(T (*p)[M])

Thierry
13/11/2007, 19h29
Nykoo

Citation:

Envoyé par Emmanuel Delahaye

Hélas, tu es toujours dans la confusion.

Le paramètre qui permet à une fonction d'accéder à un tableau est toujours un pointeur.

En 1D, on écrit (T est le type, p le pointeur et N le nombre d'éléments) :

f (T p[N]) ou f (T p[]) ou f (T *p)

N étant 'à gauche' (c'est pas frappant quand il n'y a qu'une dimension, OK), il peut être omis.

Le paramètre est une 'adresse de type T'.

Ce trois pointeurs sont strictement identiques, parce qu'on est dans le cadre d'un paramètre de fonction.

En 2 D, on écrit :

f (T p[N][M]) ou f (T p[][M]) ou f (T *p[M])

Les 3 notations sont identiques et le paramètre est une 'adresse de type tableau de M x T'. p est donc bien un pointeur.

Ok donc:

p[N][M] (lorsqu'il est en paramètre dans un prototype de fonction) n'est pas interprété comme "d'habitude": p[N][M] = *(p+N*M+M) C'est une nouvelle notation.

J'espère ne pas dire de bétises encore.
14/11/2007, 00h08
Thierry Chappuis

Citation:

Envoyé par Nykoo

Ok donc:

p[N][M] (lorsqu'il est en paramètre dans un prototype de fonction) n'est pas interprété comme "d'habitude": p[N][M] = *(p+N*M+M) C'est une nouvelle notation.

J'espère ne pas dire de bétises encore.

Non, il me semble que tu te torture le cerveau pour rien. il n'y a pas de déréférencement ou d'arthimétique de pointeur. Soit le prototype suivant:

Code:

void f(int p[][M]);

Ici p n'est rien d'autre qu'un pointeur destiné à recevoir l'adresse du 1er élément du tableau qu'on désires utiliser dans le corps de la fonction. Si tu as compris comment fonctionne le passage de l'adresse d'un tableau à 1D en argument d'une fonction, ici, il n'y a absolument rien de nouveau.

Thierry