Passage d'une matrice à une fonction

Version imprimable

J'ai un tableau à 2 dimensions que je veux remplir à partir d'une fonction et l'afficher à partir d'une autre J'ai donc créé mes deux fonctions mais ça marche pas est ce que quelqu'un peut m'aider

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>
#define N 2
#define M 3
void remplir(int *tab);
void affichage(int *tab);
int main()
{
    int m[1][2];
    remplir(m);
    affichage(m);
    return 0;
}
void remplir(int *tab)
{
int i=0;
int j=0;
for(i=0;i<N;i++)
 {
     for(j=0;j<M;j++)
     {
        tab[i][j]=i+j;
     }
 }
}
void affichage(int *tab){
    int i=0;
    int j=0;
for(i=0;i<N;i++)
 {
     for(j=0;j<M;j++)
     {
        printf("%d\t",tab[i][j]);
     }
     printf("\n");
 }
}

21/10/2010, 00h31
Nudger

Bonsoir,

Le tab++ dans affichage il est de trop à mon avis.
21/10/2010, 00h31
Melem

tab est de type int * donc étant donné un entier k, tab[k] est un int. Du coup, étant donné un entier n, tab[k][n] est un expression invalide car tab[k] est un int, pas un tableau. Ainsi les "tab[i][j]" que l'on rencontre dans chacune de tes fonctions provoqueront toutes des erreurs à la compilation. En fait, il faut écrire tab[N*i + j] à la place de tab[i][j], les explications se trouvant ici. Supprimer également le tab++ dans l'affichage.
21/10/2010, 00h49
Nudger

exact, je n'avais pas vu ça aussi.
autre solution: garder le tableau à deux dimensions et passer les signatures des fonctions pour prendre int **tab comme argument.
21/10/2010, 10h05
Melem

Citation:

Envoyé par Nudger

autre solution: garder le tableau à deux dimensions et passer les signatures des fonctions pour prendre int **tab comme argument.

Hélas non, c'est une erreur fatale. En mémoire, il n'y a aucune différence entre int m[3][4] et int m[12], c'est pour ça qu'on peut utiliser int * pour pointer sur un tableau de int de n'importe quelle dimension et y accéder à n'importe quel élément en faisant un bon calcul d'adresse comme je l'ai montré. Un int ** par contre permet de pointer sur un tableau (à une dimension) de pointeurs. int ** sert donc plutôt à manipuler les "tableaux à deux dimensions" alloués dynamiquement, les tableaux de pointeurs (int * m[3] par exemple), mais certainement pas les tableaux à deux dimensions statiques (comme int m[3][4]). Ce sujets sont beaucoup traités dans les cours et FAQ de developpez.

merci les amis pour votre aide pour le "tab++" c'était une erreur de frape
voila la version corrigée

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>
#define N 2
#define M 3
void remplir(int *tab);
void affichage(int *tab);
int main()
{
    int m[1][2];
    remplir(m);
    affichage(m);
    return 0;
}
void remplir(int *tab)
{
int i=0;
int j=0;
for(i=0;i<N;i++)
 {
     for(j=0;j<M;j++)
     {
        tab[i][j]=i+j;
     }
 }
}
void affichage(int *tab){
    int i=0;
    int j=0;
for(i=0;i<N;i++)
 {
     for(j=0;j<M;j++)
     {
        printf("%d\t",tab[i][j]);
     }
     printf("\n");
 }
}

22/10/2010, 23h10
Med_be

s'il vous plait proposez moi une correction :cry:
23/10/2010, 12h08
diogene
1- il vaudrait mieux que le tableau soit de la bonne taille. Comme tu l'écris et l'affiches avec des indices allant de 0 à N-1 et 0 à M-1, ce doit être un tableau NxM, pas 1x2
Code:

1 2 3 4 5 6 7 int main(void) { int m[N][M]; remplir(m); affichage(m); return 0; }
2- L'argument des fonctions est m. Du coup, le type des paramètres des fonctions est incorrect : il doit être "adresse d'un élément du tableau m". Le tableau m est un tableau de N tableaux de M int. Le type doit être "adresse d'un tableau de M int" : int (*)[M]
Code:

1 2 void remplir(int (*tab)[M]); void affichage(int (*tab)[M]);
Les choses devraient alors aller mieux.

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
#include <stdio.h>
#include <stdlib.h>
#define N 2
#define M 3
void remplir(int (*tab)[M]);
void affichage(int (*tab)[M]);
int main()
{
    int m[N][M];
    remplir(m);
    affichage(m);
    return 0;
}
void remplir(int (*tab)[M])
{
int i=0;
int j=0;
for(i=0;i<N;i++)
 {
     for(j=0;j<M;j++)
     {
        tab[i][j]=i+j;
     }
 }
}
void affichage(int (*tab)[M]){
    int i=0;
    int j=0;
for(i=0;i<N;i++)
 {
     for(j=0;j<M;j++)
     {
        printf("%d\t",tab[i][j]);
     }
     printf("\n");
 }
}

ça marche mtn merci bien :D
mais j'ai pa bien compris cette partie du Code (*tab)[M] :( est ce que tu peux me la ré-expliquer plus en détail ou m'envoyer 1 tuto qui aborde ce sujet
MERCI

06/11/2010, 16h45
diogene
Quelques éléments concernant la manière dont le C traite les tableaux (quel que soit leur nombre de dimensions).

I- Rappellons d'abord quelques éléments de syntaxe C :

a- En C, le type de l'adresse d'un objet de type T s'écrit T*.
Exemple : définition d'un type Tai "adresse d'un int" :
Code:

1 2 typedef int *Tai; // *Tai est int // Tai est adresse de int
b- En C, le type d'un tableau d'objets de type T s'écrit T [].
Exemple : définition d'un type Tti "Tableau de N int"
Code:

1 2 typedef int Tti[N]; // Tti[N] est int // Tti est tableau de N int
c- Si on veut combiner les deux et écrire le type Tat : "adresse d'un tableau de N int" , on aura alors
Code:

1 2 typedef int (*Tat)[N] // *Tat est du type "tableau de N int" (d'après b) // Tat est du type " adresse d'un tableau de N int" (d'après a)
Les parenthèses sont obligatoires sinon on a
Code:

1 2 typedef int *Tat[N]; // Tat[] est du type int *. (d'après a) // Tat est du type "tableau de N pointeurs sur int" (d'après b)
Les parenthèses permettent d'inverser l'ordre d'application des règles a et b qui sinon est imposée par les priorités respectives de * et [].

II- Cas des tableaux :

On crée un tableau de N éléments de type T (éléments qui peuvent être des tableaux) : T tab[N].
C'est un objet (de type tableau) et comme tout objet en C, il a une adresse et une occupation mémoire. On peut obtenir cette adresse par l'opérateur & et son occupation mémoire par l'opérateur sizeof. Mais l'identificateur tab peut représenter deux choses différentes selon la manière dont il est utilisé.

1 - tab est opérande de l'opérateur unaire & (adresse de) ou de l'opérateur sizeof : tab représente alors l'objet tableau.
Si on prend son adresse, &tab, alors la valeur obtenue sera du type "adresse d'un tableau de N éléments de type T", ce qui en C s'écrit T (*)[N] (cf I-c)
Par exemple, si je veux stocker cette adresse dans un pointeur p, j'écrirais :
T (*p)[N] = &tab;
On aura également
sizeof tab == N*sizeof(T)

Ce sont les deux seuls opérateurs applicables aux tableaux.

2- Si tab n'est pas opérande de & ou de sizeof, alors tab ne désigne pas l'objet tableau (ni un autre objet), mais une valeur qui est l'adresse du premier élément du tableau. Il est alors du type "adresse d'un élément de type T" ce qui s'écrit en C : T* (cf I-a). C'est le cas lorsque tab est argument d'une fonction f(). Dans ce cas, le paramètre de la fonction f() doit donc être du type T*.
Dans le cas des tableaux à deux dimensions, T est un type "tableau de M éléments de type Q". Je peux parfaitement écrire :
Code:

1 2 3 4 typedef Q T[M]; // définition d'un type T T tab[N]; // définition d'un objet tableau de N objets de type T f(tab); // l'appel à la fonction void f(T* t){....} // la définition de la fonction
Après la définition du type T, tout s'écrit comme pour un tableau à une dimension.

Je peux aussi ne pas définir T et le remplacer par son équivalent (Q [M]). On obtient :
Code:

1 2 3 Q tab[N][M]; f(tab);// l'appel à la fonction void f(Q (* t)[M]) {....} // la définition de la fonction
Cette dernière écriture exprime bien que t est du type "adresse d'un tableau de M éléments de type Q" (cf § I-c) (donc "adresse d'un élément du tableau tab").

Cette double interprétation est la difficulté des tableaux. Il faut donc se souvenir absolument de la différence d'interprétation selon que tab est opérande de & ou de sizeof ou non.
06/11/2010, 19h58
Med_be

Merci c'est plus claire maintenant :ccool: