Problème avec les listes chaînées

**Thierry Chappuis** · 14/10/2007, 21h23

Envoyé par yous18

oui j'ai déja lu ton lien ... mais je crois que tu me comprend pas ... je suis pas un pro .... je savoir théoriquement comment ça se passe

Si tu ne comprends pas, n'hésite pas à poser des questions précises!

Thierry

**yous18** · 14/10/2007, 23h22

merci .... je crois mnt que j'ai compri
dans ce code

Code :

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

main.c:24: warning: comparison between signed and unsigned

c'est quoi signed and unsigned ?

**Emmanuel Delahaye** · 14/10/2007, 23h35

Envoyé par yous18

merci .... je crois mnt que j'ai compri

Alors montre le code qui monre que tu as compris.

dans ce code

Quel code ?

Code :

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

main.c:24: warning: comparison between signed and unsigned

c'est quoi signed and unsigned ?

C'est un qualificateur de type. La plage des entiers unsigned va de 0 à <type>_MAX. La plage des signed va de <type>_MIN a <type>_MAX. <type>_MIN est < 0.

Les valeurs des <type>_MIN et <type>_MAX sont définies dans <limits.h>. Elles dépendent évidemment de l'implémentation.

Quand on compare des entiers de types différents, il peut y avoir un comportement non portable.

**yous18** · 15/10/2007, 13h37

Envoyé par Emmanuel Delahaye

Alors montre le code qui monre que tu as compris.

tout est dans ta reponse #19

**yous18** · 22/10/2007, 14h44

salut les amis
je voulais améliorer mon code en ajoutant un élement au milieu de la liste
et j'ai fai le code suivant :

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
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
 
 
typedef struct yous
{
        int n ;
        struct yous *suiv ;
} yous ;
 
yous *fin , *debut ,*f,*k;
 
void inser(int a)
{
     yous *p;
     p=(yous*)malloc(sizeof(yous));
 
     p->n = a ;
     p->suiv = NULL ;
     fin->suiv = p ;
}  
 
void aff(yous *q)
{  
 
    while(q!= NULL)
    {
    printf("%d\n",q->n);
    q=q->suiv ;
    } 
}
 
 
main()
{
    int i,a,j;
 
    debut=(yous*)malloc(sizeof(yous));
    f=(yous*)malloc(sizeof(yous));
    k=(yous*)malloc(sizeof(yous));
 
 
    debut->n = 1 ;
    //debut->suiv = NULL ;
 
    fin = debut ;
    i=0 ;
    do 
    {   
    scanf("%d",&a) ;
    inser(a);
    fin=fin->suiv ;
    i++ ;
    }
    while ( i!=4 );
 
    printf("\n");
 
    aff(debut);
    printf("\n");
 
    k=debut ;
    while(j!=2)
    {
              k=k->suiv ;
              j++;
    }
    f->n=12;
    f->suiv=k->suiv;
    k->suiv=f;
 
    aff(debut);         
getch();
}

mais le .exe plante avant le 2éme affichage
alors c'est quoi le probléme ?
une autre chose

Code :

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

1
2
    debut->n = 1 ;
    //debut->suiv = NULL ;

avant de supprimer la 2éme ligne le .exe faisait une boucle infine des chiffres ...bref un comportement indefini .... pourquoi ?

**Médinoc** · 22/10/2007, 14h55

Tu joues avec une variable globale (fin), mais tu oublies de la mettre à jour dans ta fonction d'ajout.
Et il y a sûrement aussi d'autres erreurs, je n'ai pas cherché beaucoup plus loin.

PS: Retire le cast de ton malloc() il est inutile et déconseillé en C depuis l'errata du K&R2.

**yous18** · 22/10/2007, 15h13

non la fonction ajout ou plutot inser marche très bien
le problème est ici lorsque je voulai ajouter 12

Code :

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

1
2
3
4
5
6
7
8
9
10
11
k=debut ;
    while(j!=2)
    {
              k=k->suiv ;
              j++;
    }
    f->n=12;
    f->suiv=k->suiv;
    k->suiv=f;
 
    aff(debut);

de quel malloc tu parle ? car elle trés util sinon le programme plante .

**Médinoc** · 22/10/2007, 16h14

Envoyé par yous18

non la fonction ajout ou plutot inser marche très bien

Et moi je dis qu'elle est bugguée, car après un inser(), la structure sur laquelle pointe fin n'est plus la fin de la liste.

de quel malloc tu parle ? car elle trés util sinon le programme plante .

Je ne parle pas de retirer un malloc(), je parle de retirer les casts de tous les malloc(). Encore que, en regardant ton main(), je me dis qu'il doit quand même y avoir des malloc() en trop.

En plus, avec tes noms de variables à une lettre, on dirait que tu fais exprès de rentre ton code peu lisible.

**yous18** · 22/10/2007, 21h21

Envoyé par Médinoc

Et moi je dis qu'elle est bugguée, car après un inser(), la structure sur laquelle pointe fin n'est plus la fin de la liste.
.

comment ça je t'ai pas compri ... car elle travaille tres bien avec moi la fonction inser ...
je crois que tu n'a pas compri car inser elle ajoute les élements dans la liste qui est vide ... mais moi je voulai ajouter juste un element au milieu de la liste c'est pour ça j'ai mi le code suivant (pas de fonction) :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
    k=debut ;
    while(j!=2)
    {
              k=k->suiv ;
              j++;
    }
    f->n=12;
    f->suiv=k->suiv;
    k->suiv=f;
 
    aff(debut);

P.S je sai qu'il y a une fonction pour ajouter les element mais moi je suis encors un debutant et je voulai savoir si mon code est juste...

Envoyé par Médinoc

je parle de retirer les casts ? de tous les malloc(). Encore que, en regardant ton main(), je me dis qu'il doit quand même y avoir des malloc() en trop. ou ?
.

tu peux m'xpliquer trop quand elle sert à rien ?

**Médinoc** · 22/10/2007, 22h41

En fait, je peux te confirmer qu'inser() était bugguée. Mais tu contournais le bug en modifiant fin en dehors de inser(), dans ton main(). C'est dans la fonction inser() qu'il aurait fallu le faire.

Voici ton code corrigé (sauf pour la fin du main()) et commenté:

Code C :

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
#include<stdio.h>
#include<stdlib.h>
#include<assert.h> 
 
typedef struct yous
{
	int n ;
	struct yous *suiv ;
} yous ;
 
/* Utiliser une structure spécifique pour la liste */
typedef struct liste
{
	yous *pPremier;
	yous *pDernier;
} liste;
 
/* On vire les variables globales */
 
/* Prend la liste en paramètre.
   Retourne 0 si OK, -1 si erreur. */
int InserPremier(liste *pListe, int val)
{
	yous *pNouveau = NULL;
	assert(pListe != NULL);
 
	/* Crée */
	pNouveau = malloc(sizeof(*pNouveau));
	if(pNouveau == NULL)
		return -1;
	pNouveau->n = val;
	pNouveau->suiv = NULL;
 
	/* Insère */
	if(pListe->pPremier==NULL)
	{
		/* La liste est vide */
		pListe->pPremier = pNouveau;
		pListe->pDernier = pNouveau;
	}
	else
	{
		/* Insère en tête de liste */
		pNouveau->suiv = pListe->pPremier;
		pListe->pPremier = pNouveau;
		assert(pListe->pDernier != NULL);
	}
	return 0;
}  
 
/* Prend la liste en paramètre.
   Retourne 0 si OK, -1 si erreur. */
int AjoutDernier(liste *pListe, int val)
{
	yous *pNouveau = NULL;
	assert(pListe != NULL);
 
	/* Crée */
	pNouveau = malloc(sizeof(*pNouveau));
	if(pNouveau == NULL)
		return -1;
	pNouveau->n = val;
	pNouveau->suiv = NULL;
 
	/* Ajoute */
	if(pListe->pPremier==NULL)
	{
		/* La liste est vide */
		pListe->pPremier = pNouveau;
		pListe->pDernier = pNouveau;
	}
	else
	{
		/* Ajoute en fin de liste */
		assert(pListe->pDernier != NULL);
		assert(pListe->pDernier->suiv == NULL);
		pListe->pDernier->suiv = pNouveau;
		pListe->pDernier = pNouveau;
	}
	return 0;
}  
 
void Affiche(liste *pListe)
{  
	yous *pCourant = NULL;
	assert(pListe != NULL);
 
	pCourant = pListe->pPremier;
	while(pCourant!= NULL)
	{
		printf("%d\n", pCourant->n);
		pCourant = pCourant->suiv ;
	} 
}
 
 
int main(void)
{
	/* Pas besoin d'allocation ici */
	liste uneListe = {NULL, NULL}; /* Initialiser à NULL: Indispensable! */
 
	int i=0;
	do 
	{
		int a;
		printf("Entrer un nombre : ");
		fflush(stdout); /* Pour que le printf() marche toujous */
		scanf("%d", &a) ;
		AjoutDernier(&uneListe, a);
		i++ ;
	}
	while ( i!=4 );
 
	printf("\n");
 
	Affiche(&uneListe);
	printf("\n");
 
	/* ?? Je ne comprends pas exactement ce que tu cherches à faire ici.
	   Tes noms de variables sont trop obscurs...
	k=debut ;
	while(j!=2)
	{
		k=k->suiv ;
		j++;
	}
	f->n=12;
	f->suiv=k->suiv;
	k->suiv=f;*/
 
	/*Affiche(&uneListe);*/
	/*getch();*/
	return 0;
}

**yous18** · 23/10/2007, 13h30

merci ...mais pour mon code pour l'ajout au milieu il y a pas quelq'un qui a la solution ?

**Médinoc** · 23/10/2007, 14h12

Pour l'ajout au milieu: Tu obtiens un pointeur sur le second élement, puis du utilises une fonction pour insérer juste après:

Code C :

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
/* Récupère l'élément d'index demandé ou retourne NULL.
   Le premier élément a l'index zéro. */
yous * GetChainon(liste *pListe, size_t index)
{
	yous *pCourant = NULL;
	assert(pListe != NULL);
 
	pCourant = pListe->pPremier;
	while(index)
	{
		if(pCourant==NULL)
			return NULL;
		pCourant = pCourant->suiv;
		index--;
	}
	return pCourant;
}
 
int InserApres(liste *pListe, yous *pApresQui, int val)
{
	yous *pNouveau = NULL;
	assert(pListe != NULL);
	assert(pListe->pPremier != NULL);
	assert(pApresQui != NULL);
 
	/* Crée */
	pNouveau = malloc(sizeof(*pNouveau));
	if(pNouveau == NULL)
		return -1;
	pNouveau->n = val;
	pNouveau->suiv = NULL;
 
	/* Insere */
	pNouveau->suiv = pApresQui->suiv;
	pApresQui->suiv = pNouveau;
	/* Ajuste si dernier*/
	if(pListe->pDernier==pApresQui)
	{
		/* C'est en fin de liste qu'on ajoute */
		pListe->pDernier = pNouveau;
	}
	return 0;
}

Code C :

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
int main(void)
{
	/* Création liste */
	liste uneListe = {NULL, NULL}; /* Initialiser à NULL: Indispensable! */
 
	int i=0;
	do 
	{
		int a;
		printf("Entrer un nombre : ");
		fflush(stdout); /* Pour que le printf() marche toujous */
		scanf("%d", &a) ;
		AjoutDernier(&uneListe, a);
		i++ ;
	}
	while ( i!=4 );
 
	printf("\n");
 
	Affiche(&uneListe);
	printf("\n");
 
	/* Insertion au milieu */
	{
		yous *pAvantMilieu = GetChainon(&uneListe, 1);
		assert(pAvantMilieu != NULL);
		InserApres(&uneListe, pAvantMilieu, 12);
	}
	Affiche(&uneListe);
	return 0;
}

Note: Je n'ai pas testé ce code.

**yous18** · 23/10/2007, 14h46

pour ce assert.h quel est son role ?

**Emmanuel Delahaye** · 23/10/2007, 14h57

Envoyé par yous18

pour ce assert.h quel est son role ?

http://emmanuel-delahaye.developpez....tes.htm#assert

**Médinoc** · 23/10/2007, 14h59

Ici, ce sont les erreurs d'utilisation des fonctions que je teste (sauf pour l'assertion dans le main()) : Je m'assure qu'on n'appelle pas les fonctions avec un pointeur nul ou une liste incorrecte.

**yous18** · 25/10/2007, 01h54

merci .. mais pour mon code je l'ai simplifié vous pouvez me dire ou je me trompe

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
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
 
 
typedef struct yous
{
        int n ;
        struct yous *suiv ;
} yous ;
 
yous *fin , *debut ,*f,*k;
 
void inser(int a)
{
     yous *p;
     p=(yous*)malloc(sizeof(yous));
 
     p->n = a ;
     p->suiv = NULL ;
     fin->suiv = p ;
}  
 
void aff(yous *q)
{  
 
    while(q!= NULL)
    {
    printf("%d\n",q->n);
    q=q->suiv ;
    } 
}
 
 
int main(void)
{
    int i,a,j;
 
    debut=(yous*)malloc(sizeof(yous));
    f=(yous*)malloc(sizeof(yous));
 
 
 
    debut->n = 1 ;
    //debut->suiv = NULL ;
 
    fin = debut ;
    i=0 ;
    do 
    {   
    scanf("%d",&a) ;
    inser(a);
    fin=fin->suiv ;
    i++ ;
    }
    while ( i!=4 );
 
    printf("\n");
 
    aff(debut);
    printf("\n");
 
    k=debut ;/* k est le maillon apres lequel je vais inserer le maillon f */
    while(j!=2)
    {
              k=k->suiv ;
              j++;
    }
    f->n=12;
    f->suiv=NULL;
    f->suiv=k->suiv;
 
    k->suiv=f;
 
    aff(debut);   
 
getch();
return 0;
}

car j'ai suivi les information deduit de cette photo

**Médinoc** · 25/10/2007, 09h21

Ce code "simplifié" est reste trop en bordel pour moi. Essaie de faire des fonctions qui font une tâche précise et le font bien...

Ta ligne fin=fin->suiv ; après l'appel à inser() devrait être DANS la fonction inser(), tu utilises trop de variables globales (f et k, les pointeurs au nom si évocateur

, n'ont AUCUNE raison d'être globales), et tes malloc() sont toujours castés alors que ça ne sert à rien.

Remarques en bref:

Tu devrais retarder l'allocation de f et ne la faire qu'à la fin, car tu n'en a pas besoin plus tôt. Initialise f à NULL.
Si tu tentes de suivre le schéma à la lettre, c'est mal parti: Le schéma part d'une liste de trois et y ajoute un élément, ton code part d'une liste de cinq...