Discussion :

[isoman]

salut j'aimerais passer une liste en parametre ,normalement l'execution doit afficher -1 0 1 2 3 .
si je fais un passage par valeur tout marche mais si je modifie la fonction pour avoir un passage par adresse ça ne marche pas correctement!(ça affiche -1 2 3).
voila mon code :

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
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
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
 
#include <stdio.h>
#include <stdlib.h>
#define type int
 
 
typedef struct cellule
{
        int  data;
        struct cellule *suiv;
        struct cellule *avt;
}cellule;
typedef cellule *liste;
 
 
int listeestvide(liste l)//testé
{
        if (l==NULL)
        {
                return 0;
        }
        else
        {
                return 1;
        }
}
int debut(liste l)
{
        return (int) l;
}
 
int fin(liste l)
{
        liste p=l;
        if (listeestvide(l)==1)
        {
                while(p->suiv!=NULL)
                {
                        p=p->suiv;
                }
                return (int)(p);
        }
        else
        return (int)(NULL);
}
 
 
void ajoutertete(liste *l,type elmt)
{
        cellule *nv;
        nv=malloc(sizeof(type));
        nv->data=elmt;
        nv->suiv=*l;
        *l=nv;
 
}
void  ajouterfin(liste *l,type elmt)
{
 
        cellule *nv;
        liste *p=l;
        nv=malloc(sizeof(type));
 
        nv->data=elmt;
        nv->suiv=NULL;
        if (listeestvide(*l)==1)
        {
                while((*p)->suiv!=NULL)
                {
                        *p=(*p)->suiv;
                        puts("here");
 
                }
                (*p)->suiv=nv;
 
                }
        else
        {
                *l=nv;
                puts("here");
        }
}
 
 
void affichertout(liste l)
{
        liste p=l;
        int i=1;
        while(p!=NULL)
        {
 
                printf("noeud %d:%d\n",i,p->data);
        p=p->suiv;
        i++;
        }
}
int main(void)
{
        liste l=NULL;   
        ajoutertete(&l,0);
        ajouterfin(&l,1);
        ajouterfin(&l,2);
        ajouterfin(&l,3);
        ajoutertete(&l,-1);
        affichertout(l);
return 0;
}

merci

[Médinoc]

1. Tu oublies d'utiliser type pour la donnée.
2. Ta fonction listestvide() est à l'envers. Elle devrait retourner 0 si la liste n'est PAS vide et retourner une valeur non-nulle (n'importe laquelle ferait l'affaire) si la liste est effectivement vide.
3. NULL est pour les pointeurs. On ne retourne pas NULL casté en int. Tu dois te définir une autre valeur invalide (genre zéro (mais le vrai zéro, cette foi-ci) ou INT_MIN (défini dans <limits.h>)...
4. Je n'avais pas vu la fin de la fonction, c'est pire que je le pensais. Tu retournes l'adresse du chaînon, castée en int. On peut savoir pourquoi tu fais une aberration pareille ?
5. Tu alloues beaucoup trop peu: Il y a de la place pour le int, mais pas pour les deux pointeurs... Tu dois allouer une structure cellule et pas un simple int...

[isoman]

Je n'avais pas vu la fin de la fonction, c'est pire que je le pensais. Tu retournes l'adresse du chaînon, castée en int. On peut savoir pourquoi tu fais une aberration pareille ?

,c'est pour avoir l'adresse du noeud qui est en fin de liste.
J'ai reparé les autres erreurs mais ça ne marche pas .

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
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
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
 
#include <stdio.h>
#include <stdlib.h>
#define type int
 
 
typedef struct cellule
{
	type data;
	struct cellule *suiv;
	struct cellule *avt;
}cellule;
typedef cellule *liste;
 
 
int listeestvide(liste l)//testé
{
	if (l==NULL)
	{
		return 1;
	}
	else
	{
		return 0;
	}
}
int debut(liste l)
{
	return (int) l;
}
 
int fin(liste l)
{
	liste p=l;
	if (listeestvide(l)==0)
	{
		while(p->suiv!=NULL)
		{
			p=p->suiv;
		}
		return (int)(p);
	}
	else 
	return (int)(NULL);
}
 
 
void ajoutertete(liste *l,type elmt)
{
	cellule *nv;
	nv=malloc(sizeof(cellule));
	nv->data=elmt;
	nv->suiv=*l;
	*l=nv;
 
}
//PASSAGE PAR ADRESSE . NE MARCHE PAS !!!!!
void  ajouterfin(liste *l,type elmt) 
{
 
	cellule *nv;
	liste *p=l;
	nv=malloc(sizeof(cellule));
 
	nv->data=elmt;
	nv->suiv=NULL;
	if (listeestvide(*l)==0)
	{
		while((*p)->suiv!=NULL)
		{
			*p=(*p)->suiv;
			puts("here");
 
		}
		(*p)->suiv=nv;
 
		}
	else
	{
		*l=nv;
		puts("here");
	}
 
}
 
int acces(liste l,int pos)
{
	int i=0;
	liste p=l;
	if (listeestvide(l)==0)
	{
		return -1;
	}
	else
	{
		while(p!=NULL && (int)p!=pos)
		{
			p=p->suiv;
		}
	}
	if ((int)p==pos)
	{
 
		return p->data;
	}
	else
	{
		return 0;
	}
}
 
 
 
void affichertout(liste l)
{
	liste p=l;
	int i=1;
	while(p!=NULL)
	{
 
		printf("noeud %d:%d\n",i,p->data);
	p=p->suiv;
	i++;
	}
}
int main(void)
{
        liste l=NULL;   
        ajoutertete(&l,0);
        ajouterfin(&l,1);
        ajouterfin(&l,2);
        ajouterfin(&l,3);
        ajoutertete(&l,-1);
        affichertout(l);
return 0;
}

[Médinoc]

c'est pour avoir l'adresse du noeud qui est en fin de liste.

C'est débile.
Un int, c'est pour un nombre. Pour une adresse, on utilise un pointeur...

[Médinoc]

Ton code revu et corrigé:

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
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
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
#include <stdio.h>
#include <stdlib.h>
 
/* Utiliser typedef plutôpt que #define, pour les types */
typedef int type_t;
 
/* Eviter d'utiliser le même nom pour la structure et le typedef */
typedef struct cellule
{
	type_t data;
	struct cellule *suiv;
	struct cellule *avt;
} cellule_s;
typedef cellule_s *liste_t;
 
 
 
/* Eviter d'utilser l comme nom de variable: On risque trop de confondre avec 1. */
int listeestvide(liste_t li)
{
	if(li==NULL)
	{
		return 1;
	}
	else
	{
		return 0;
	}
}
 
/* Répète après moi:
   On-n'u-ti-li-se-ja-mais-de-int-pour-u-na-dres-se */
cellule_s * debut(liste_t li)
{
	return li;
}
 
cellule_s * fin(liste_t li)
{
	liste_t p = li;
	/* Utiliser directement les tests implicites !=0 */
	if( ! listeestvide(li) )
	{
		while(p->suiv != NULL)
		{
			p = p->suiv;
		}
		return p;
	}
	else
		return NULL;
}
 
 
void ajoutertete(liste_t *pLi, type_t elmt)
{
	/* Une bonne pratique à prendre: TOUJOURS initialiser les pointeurs. */
	cellule_s *nv = NULL;
 
	/* Verifier les données */
	if(pLi == NULL)
	{
		puts("Erreur: appel de ajoutertete() avec pointeur NULL!");
		exit(EXIT_FAILURE);
	}
 
	/* Utiliser sizeof (*pointeur) autant que possible. */
	nv = malloc(sizeof(*nv));
	/* Toujours tester le retour de malloc(). */
	if(nv != NULL)
	{
		nv->data = elmt;
		nv->suiv = *pLi;
		*pLi = nv;
	}
}
 
 
void ajouterfin(liste_t *pLi, type_t elmt) 
{
	cellule_s *nv;
 
	/* Verifier les données */
	if(pLi == NULL)
	{
		puts("Erreur: appel de ajouterfin() avec pointeur NULL!");
		exit(EXIT_FAILURE);
	}
 
	nv = malloc(sizeof(*nv));
	/* Toujours tester le retour de malloc(). */
	if(nv != NULL)
	{
		nv->data = elmt;
		nv->suiv = NULL;
 
		/* Maintenant, si la liste est vide, on modifie *pLi.
		   Sinon, on ajoute juste un chaînon à la fin. */
		if(listeestvide(*pLi))
		{
			/* Création d'une liste */
			*pLi = nv;
		}
		else
		{
			/* Ajout à la fin de la liste */
			liste_t pDernierChainon = fin(*pLi);
			if(pDernierChainon == NULL)
			{
				puts("Erreur: La liste n'a pas de dernier chaînon, alors qu'elle est supposée être non-vide.");
				exit(EXIT_FAILURE);
			}
			pDernierChainon->suiv = nv;
		}
	}
}
 
 
/* Utiliser type_t ici aussi. 
   Ici, type_t peut être n'importe quoi, 
   on va donc demander la valeur invalide
   au lieu de la décider dans la fonction.
 
   J'ai également changé la valeur du int: Maintenant, 
   il s'agit simplement d'un index, de 0 à taille_de_la_liste-1... */
type_t acces(liste_t li, int index, type_t invalide)
{
	liste_t p = li;
	if(listeestvide(li))
	{
		return invalide;
	}
	else
	{
		int i=0;
		while(p!=NULL && i!=index)
		{
			p = p->suiv;
		}
	}
 
	if(p != NULL)
	{
		return p->data;
	}
	else
	{
		return invalide;
	}
}
 
void affichertout(liste_t li)
{
	liste_t p=li;
	int i=1;
	while(p!=NULL)
	{
		/* Attention, le format suppose que type_t est toujours un int... */
		printf("noeud %d:%d\n", i, p->data);
		p = p->suiv;
		i++;
	}
}
 
int main(void)
{
	liste_t li = NULL;
	ajoutertete(&li,0);
	ajouterfin(&li,1);
	ajouterfin(&li,2);
	ajouterfin(&li,3);
	ajoutertete(&li,-1);
	affichertout(li);
	return 0;
}

PS: Si d'aventure tu décidais encore de fourrer un pointeur dans un type entier, aies au moins l'élégance d'utiliser le type intptr_t, qui est fait pour ça...

[isoman]

et pourqoi c'est mal de faire ça ?

[Médinoc]

Parce que je connais au moins deux architectures où un pointeur n'a pas la même taille qu'un int...

[isoman]

est ce que exit() quitte tous le programme , quelle est la valeur de EXIT_FAILURE et elle est stocké ou ?
merci bcp.

[Médinoc]

Oui, exit() quitte tout le programme.
En fait, j'est le genre d'erreur pour lequel j'aurais mis des assertions, mais comme je suppose que tu ne sais pas ce que c'est, j'ai mis un truc plus compréhensible.

Les constantes EXIT_SUCCESS et EXIT_FAILURE sont définies dans <stdlib.h>, il me semble.