Problème avec les piles (chaînées)
Bonsoir, j'en ai eu tellement marre de ne pas trouver mon erreur que je viens demander au secours ici !
J'ai voulu faire un peu de C pour me remettre d'aplomb, en commençant par une truc "basique", les piles.
Dans le doute je vais poster tout le code puis j'expliquerai mon problème ^^
J'ai fais un .c, un .h et un main :
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
|
//pile.h
#ifndef _PILE_H_
#define _PILE_H_
#include <stdio.h>
#include <stdbool.h>
typedef struct s_pile Pile;
typedef struct s_element Element;
Pile *creerPile();
void supprimerPile (Pile *p);
Pile *viderPile (Pile *p);
void *sommet (Pile *p);
void empiler (Pile *p, void* e);
void* depiler (Pile *p);
bool vide (Pile *p);
size_t taille (Pile *p);
void afficherGeneral (Pile *p, void (*affSpec)(void *e));
#endif |
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
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
|
//pile.c
#include "pile.h"
#include <assert.h>
#include <stdlib.h>
struct s_element {
void* valeur;
struct s_element *suivant;
};
struct s_pile {
Element *sommet;
size_t taille;
};
Pile *creerPile() {
Pile *p = malloc(sizeof(struct s_pile));
p->sommet = NULL;
p->taille = 0;
return p;
}
void supprimerPile (Pile *p) {
Element *aSuppr = p->sommet;
while (aSuppr) {
Element *f = aSuppr;
aSuppr = aSuppr->suivant;
free(f);
}
free(p);
p=NULL;
}
bool vide (Pile *p) {
return (p->taille == 0);
}
Pile *viderPile (Pile *p) {
if (vide(p))
return p;
Element *aSuppr = p->sommet;
while (aSuppr) {
Element *f = aSuppr;
aSuppr = aSuppr->suivant;
free(f);
}
p->sommet = NULL;
p->taille = 0;
return p;
}
void *sommet (Pile *p) {
if (vide(p)) {
printf("La pile est vide !\n");
exit(1);
}
return (p->sommet->valeur);
}
size_t taille (Pile *p) {
return p->taille;
}
void empiler (Pile *p, void* e) {
Element *nouveauSommet = (Element *)malloc(sizeof(Element));
nouveauSommet->valeur = e;
nouveauSommet->suivant = p->sommet;
p->sommet = nouveauSommet;
p->taille ++;
}
void* depiler (Pile *p) {
assert (!vide(p));
Element *suppr = p->sommet;
p->sommet = p->sommet->suivant;
void* e = suppr->valeur;
free(suppr);
p->taille --;
return e;
}
void afficherGeneral (Pile *p, void (*affSpec)(void *e)) {
printf("Taille de la pile : %ld\n", p->taille);
while (p->sommet != NULL) {
affSpec(p->sommet->valeur);
p->sommet = p->sommet->suivant;
}
} |
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
|
//main.c
#include "pile.h"
#include <stdlib.h>
void afficher (void* e) {
printf("%d\n", *(int*)e);
}
int main()
{
Pile *p = creerPile();
int *i = (int*)malloc(sizeof(int));
*i=0;
empiler(p,i);
*i=1;
empiler(p,i);
*i=2;
empiler(p,i);
*i=3;
empiler(p,i);
afficherGeneral (p, afficher);
return 0;
} |
L'exécution du main me donne :
Taille de la pile : 4
3
3
3
3
en gros j'ai mon sommet qui est affiché 4 fois.
J'ai testé pleins de main, j'ai rajouté des fonctions intermédiaires et fait pleins d'affichages au fur et à mesure, et au fur et à mesure de mon empiler j'ai bien le sommet qui prend la valeur de 0, puis 1, 2 et 3. Avec des fonctions intermédiaires pour afficher le suivant, le suivant du suivant,... , je constate que le suivant prend la valeur de mon nouveau sommet (j'ai pourtant l'impression de le faire dans le bon sens dans le code), et tous les autres suivants prennent cette valeur. Ou alors mon affiche est mauvais mais je ne vois pas comment faire autrement.
Merci d'avoir pris le temps de me lire et de prendre le temps de me répondre, bonne continuation à vous et bon courage pour comprendre mon erreur (qui doit etre toute bête comme 95% des erreurs en programmation :D ) !
