Discussion :

[black_hole]

Bonjour
j'ai un probleme avec les struct ,je ne sais pas comment les utiliser.
Le programme suivant me cré un probleme

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
typedef int VEC_COMP[10][10];
 
void Mise_a_zeroC(VEC_COMP v){
    int i;
    int *p;
    p=v;
    for(i=0;i<100;i++,p++)
        *p=0;
}
void AfficheC(VEC_COMP v){
    int i;
    int *p;
    p=v;
    putchar('\n');
    for(i=0;i<100;i++,p++)
        printf("%d  ",*p);
    putchar('\n');
}

et ce programme egalement

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
struct VEC_L {
    int VAL [2];
    struct VEC_L * suivant ;
};
typedef struct VEC_L VEC_LIST, * suite;
 
void Mise_a_zeroL(VEC_LIST V,int n){
    if(!n==0)
    {
        V.VAL[0]=0;
        V.VAL[1]=0;
        Mise_a_zeroL(V.suivant,n-1);
    }else 
     {
    V.suivant=null;
    V.VAL[0]=0;
    V.VAL[1]=0;
    }
 
}
void AfficheL(VEC_LIST v,int indice){
    if(indice==0)
    {
        printf("%d",v.VAL[0]);
        printf("%d",v.VAL[1]);
    }else
    {    
        printf("%d",v.VAL[0]);
        printf("%d",v.VAL[1]);
        AfficheL(v.suivant,n-1);
    }
}

Si quelqu'un peut trouver la solution ...
D'avance merci .

[diogene]

Pour le premier programme, tu as un problème de type :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
typedef int VEC_COMP[10][10];
 
void Mise_a_zeroC(VEC_COMP v)
{
    int *p;
    p=v;...

v est du type int (*)[10] (adresse d'un tableau de 10 int), pas du type int*. Le compilateur doit te donner un avertissement sur p = v.
En l'occurence, tu peux confirmer ta volonté de faire ce changement de type (qui n'est pas franchement faux, puisque c'est l'adresse d'un int) et éviter le warning:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

p= (int*)v;

C'est le problème de passer des tableaux à plusieurs dimensions à des fonctions. Je préfère pour ma part :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
void Mise_a_zeroC(int * v)
{
...

et appeler la fonction par

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
VEC_COMP x;
...
 Mise_a_zeroC( (int*)  x);

Pour le second problème, je n'ai pas le temps de regarder maintenant. Désolé

[Melem]

- suivant est de type struct VEC_L *.
- Mise_a_zeroL requiert en premier argument un VEC_LIST (= struct VEC_L) alors que plus bas tu passe un pointeur sur VEC_LIST (suivant). Même remarque pour AfficheL.
- La ligne

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

if (!n==0) ...

est ambiguë. Tu veux peut-être faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

if (n > 0) ...

- Pas de null en C mais NULL.
- Pour mettre un objet à zéro tu peux utiliser la fonction memset.

[Thierry Chappuis]

Pour le premier programme, tu as un problème de type :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
typedef int VEC_COMP[10][10];
 
void Mise_a_zeroC(VEC_COMP v)
{
    int *p;
    p=v;...

v est du type int (*)[10] (adresse d'un tableau de 10 int), pas du type int*. Le compilateur doit te donner un avertissement sur p = v.
En l'occurence, tu peux confirmer ta volonté de faire ce changement de type (qui n'est pas franchement faux, puisque c'est l'adresse d'un int) et éviter le warning:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

p= (int*)v;

C'est le problème de passer des tableaux à plusieurs dimensions à des fonctions. Je préfère pour ma part :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
void Mise_a_zeroC(int * v)
{
...

et appeler la fonction par

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
VEC_COMP x;
...
 Mise_a_zeroC( (int*)  x);

Pour le second problème, je n'ai pas le temps de regarder maintenant. Désolé

Pourquoi ne pas tout simplement écrire:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
 
void Mise_a_zeroC(int v[][10])
{
    int *p;
    p = v[0];...

C'est propre et on évite l'usage d'opérateur de conversion de type douteux.

Thierry

[black_hole]

merci pour vos reponses .
J'ai finalement reussi a faire fonctionner voila le code pour VEC_COMP:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
void Mise_a_zeroC(VEC_COMP v){
	int i;
	int *p;
	p=(int *)v;
	for(i=0;i<100;i++,p++)
		*p=0;
}
void AfficheC(VEC_COMP v){
	int i;
	int *p;
	p=(int *)v;
	putchar('\n');
	for(i=0;i<100;i++,p++)
		printf("%d  ",*p);
	putchar('\n');
}

mais j'ai toujours un probleme avec le code de VEC_LIST ,quand je compile il ne me met pas d'erreur mais quand je lance le programme il me met une erreur de segmentation :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
void Mise_a_zeroL(liste V,int n){
	if(n>0)
	{	VEC_LIST Vi;
		liste l;
 
		(*V).suivant=&Vi;
		(*V).VAL[0]=0;
		(*V).VAL[1]=0;
		Mise_a_zeroL((*V).suivant,n-1);
	}else 
 	{
	(*V).suivant=NULL;
	(*V).VAL[0]=0;
	(*V).VAL[1]=0;
	}
 
}
void AfficheL(VEC_LIST v, int n){
 
 
	if(n==0)
	{
		printf("%d",v.VAL[0]);
		printf("%d",v.VAL[1]);
	}else
	{	
		printf("%d",v.VAL[0]);
		printf("%d",v.VAL[1]);
		AfficheL(*v.suivant,n-1);
	}
}

[diogene]

Thierry :

Pourquoi ne pas tout simplement écrire:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
void Mise_a_zeroC(int v[][10])
{
    int *p;
    p = v[0];...

C'est propre et on évite l'usage d'opérateur de conversion de type douteux.

Tu as raison, c'est plus propre.
Toutefois, la déclaration de la fonction possède alors une ambiguité : Elle traite le tableau en 1D en laissant croire que la dimension 10 est pertinente, alors qu'en fait, la fonction est utilisable quelle que soit cette valeur (si on prend la précaution de passer également le nombre d'éléments).

J'adopte volontiers ta proposition sous la forme :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
void Mise_a_zeroC(int * v)
{...}
 
VEC_COMP x;
...
 Mise_a_zeroC(x[0]);

[Thierry Chappuis]

Thierry :

Tu as raison, c'est plus propre.
Toutefois, la déclaration de la fonction possède alors une ambiguité : Elle traite le tableau en 1D en laissant croire que la dimension 10 est pertinente, alors qu'en fait, la fonction est utilisable quelle que soit cette valeur (si on prend la précaution de passer également le nombre d'éléments).

J'adopte volontiers ta proposition sous la forme :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
void Mise_a_zeroC(int * v)
{...}
 
VEC_COMP x;
...
 Mise_a_zeroC(x[0]);

Oui, si on veut s'abstraire de la deuxième dimension, cela me semble effectivement une méthode plus propre, encore que si on désire vraiment insister sur l'aspect tableau à deux dimensions de taille variable, je suis plus favorable à l'utilisation d'un type abstrait de donnée qui pourrait être définit comme suit:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
struct Matrice
{
    int *data; /* Allocation dynamique d'un tableau de taille ligs * cols * sizeof *data */
    size_t ligs;
    size_t cols;
};
 
struct Matrice * Matrice_creer(size_t ligs, size_t cols);
void Matrice_detruire(struct Matrice **pp_self);
void Matrice_mise_a_zero(struct Matrice *p_self);
int Matrice_get(struct Matrice *p_self, size_t i, size_t j);
 
/*...*/
 
void Matrice_mise_a_zero(struct Matrice *p_self)
{
    if (p_self != NULL)
    {
        int *p;
        p = p_self->data;
        /*...*/
    }
}
 
int Matrice_get(struct Matrice *p_self, size_t i, size_t j)
{
    int ret = 0;
 
    if (p_self != NULL && i < p_self->ligs && j < p_self->cols)
    {
        size_t ncols = p_data->cols;
        ret = p_self->data[i * ncols + j];
    }
 
    return ret;
}

Thierry

[Melem]

On peu très bien passer un tableau statique de n'importe quelle dimension avec (par exemple pour un tableau à deux dimensions) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
void f(void * p, size_t nb_lignes, size_t nb_colonnes)
{
    int * t = p;
 
    ...
}

C'est très popre, très simple et très générique.

[Thierry Chappuis]

On peu très bien passer un tableau statique de n'importe quelle dimension avec (par exemple pour un tableau à deux dimensions) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
void f(void * p, size_t nb_lignes, size_t nb_colonnes)
{
    int * t = p;
 
    ...
}

C'est très popre, très simple et très générique.

Ce que je ne trouve pas très propre, c'est:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

int (*)[10] -> void * -> int *

Mais peut-être que je me complique la vie pour pas grand-chose.

Thierry

[Melem]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

int (*)[10] -> int *

Est très propre. Le premier est type est parfaitement aligné pour le second (dans la mémoire, il n'y a aucune différence entre un tableau à n dimensions et un tableau à une seule dimension) et la norme autorise la conversion. Le void * sert tout simplement à supprimer le cast.

[Médinoc]

Personnellement, je serais quand même plutôt du genre à passer explicitement &tab[0][0] à une fonction demandant un int*.

[black_hole]

merci a tous pour vos reponses je vais potasser ca .

[diogene]

Personnellement, je serais quand même plutôt du genre à passer explicitement &tab[0][0] à une fonction demandant un int*.

Mais &tab[0][0] est strictement équivalent à tab[0] puisque traduit en &*(tab[0]+0) = tab[0] de la même façon que pour un tableau 1D, passer &tab[0] au lieu de simplement tab est juste mais (à mon goût) inutilement verbeux.

[Melem]

Mais &tab[0][0] est strictement équivalent à tab[0] ...

tab[0] mais pas tab.