Pile en C ( en LIFO )

Version imprimable

Bonjour à tous,
J'ai quelque modifications à apporter à un script mais je n'y arrive pas. Le but de mon projet est de créer une pile en C au format LIFO ( last in first out ) consistant donc a ajouter / supprimer des éléments, le seul élément avec lequel on peut interagir étant celui se trouvant au sommet de la pile.

J'ai donc les scripts suivants:

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
//   	
// Fichier pile.h
//   	
 
#include <stdio.h> 
#include <stdlib.h>
typedef float Element; 
 
struct SCellule {
     Element info;
     struct SCellule *psuiv;
};
 
typedef struct SCellule *Cellule; 
 
struct SPile{
      struct SCellule *sommet;
      int nbElements;
};
 
typedef struct SPile *Pile; Pile 
 
PileVide();
 
Pile pileAjouter(Pile p, Element e);
 
Pile pileSupprimer(Pile p);
 
Element *pileSommet(Pile p);
 
int pileLongueur(Pile p);

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
//   	
// Fichier pile.c
//   	
 
#include "pile.h"
 
Pile pileVide(){
       Pile p;
 
       p=(Pile)malloc(sizeof(struct SPile));
       p->nbElements = 0;
       p->sommet = (Cellule) NULL; 
      return (p);
}
 
Pile pileAjouter(Pile p, Element e){
       Cellule newSommet;
 
      newSommet = (Cellule)malloc(sizeof(struct SCellule)); 
      newSommet->info = e;
      newSommet->psuiv = p->sommet; 
      p->sommet = newSommet;
      p->nbElements=p->nbElements + 1;
     return (p);
}
 
 
Pile pileSupprimer(Pile p){ 
      Cellule tmp;
 
      if(p->nbElements == 0){ 
              return ((Pile)NULL);
      }
      tmp=p->sommet;
      p->sommet = tmp->psuiv; 
      free(tmp);
     p->nbElements = p->nbElements - 1; 
     return (p);
}
 
Element *pileSommet(Pile p){ 
            if(p->nbElements == 0){
                    return ((Element*)NULL);
             }
             return &(p->sommet->info);
}
 
int pileLongueur(Pile p){
 
          return p->nbElements;
}

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
//   	
// Fichier main.c
//   	
 
#include "pile.h"
 
int main(){
        Pile p; Element *elem;
        int estSommet=0;
 
        p=pileVide(); 
        pileAjouter(p,1); 
        pileAjouter(p,2); 
        pileAjouter(p,3);
 
       while(pileLongueur(p)>0){
 
               if(estSommet == 0){
                    printf("\nLe sommet de la pile est %0.2f\n\n",*pileSommet(p));
                   estSommet=1;
                }
                printf("| %0.2f |\n", *pileSommet(p)); 
                printf("------------\n");
               pileSupprimer(p);
       }
 
       return (0);
 
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#   	
# Fichier Makefile
#   	
 
BIN = piles
OBJECTS = main.o pile.o 
CC = gcc
 
all: $(OBJECTS)
      $(CC) $(OBJECTS) -o $(BIN)
 
main.o: main.c pile.h
         $(CC) -c main.c
 
vitesse.o : pile.h pile.c
             $(CC) -c pile.c
 
clean:
       rm -f $(OBJECTS) $(BIN) *~

J'obtient donc avec ce code :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
//   	
// Résultat
//   	
 
Le sommet de la pile est 3.00
 
| 3.00 |
----------
| 2.00 |
----------
| 1.00 |
---------

Ce qui est correcte. Maintenant il faudrait que je remplace les élements 1,2,3 de ma pile par : (‘’fonction#1’’, 0x7F543210, ‘’Ok’’) a la place du 1, (fonction#2’’, 0x7F543220, ‘’987654’’) a la place du 2 et (‘’fonction#3’’, 0x7F543230, ‘’123456’’) a la place du 3. Mon code ne compilant que des éléments de type float j'ai essayé de convertir chaque ligne de type str en float avec la fonction strtof() mais celle ci ne converti que les nombres englobé dans dans "".

Je dois donc avoir au final l'ordre d'execution suivant:

pileAjouter (‘’fonction#1’’, 0x7F543210, ‘’Ok’’) ;
pileAjouter (‘’fonction#2’’, 0x7F543220, ‘’987654’’) ;
pileAjouter (’fonction#3’’, 0x7F543230, ‘’123456’’) ;
pilelongueur (Pile) ;
pileafficher (Pile) ;
pileSupprimer (Pile) ;
pilelongueur(Pile) ;
pileafficher (Pile) ;

Merci pour votre aide !

24/09/2021, 15h42
foetus
En gros, tu as 2 choix :mrgreen:
*) Soit tu remplaces typedef float Element; par 1 structure.
Ensuite dans ton maillon, il faut savoir si tu stockes
- 1 element - à la création du maillon, tu passes 1 élément déjà créé : soit tu recopies les membres soit tu prends les pointeurs/ valeurs des membres.
- 1 element - à la création du maillon, tu passes chaque membre : soit tu les recopies soit tu prends leurs pointeurs/ valeurs.
- 1 pointeur d'élément - à la création du maillon, tu passes 1 élément déjà créé : soit tu prends cet élément, soit tu le recopies soit tu lui prends les pointeurs/ valeurs des membres (<- obliger de créer ton élément dans les 2 derniers cas)
- 1 pointeur d'élément - à la création du maillon, tu passes chaque membre : soit tu les recopies soit tu prends leurs pointeurs/ valeurs (<- obliger de créer ton élément dans les 2 cas)
*) Soit tu supprimes typedef float Element; et tu mets tous les membres dans ton maillon.
Ensuite c'est similaire aux 4 cas précédents, mais sans créer ton élément (puisqu'il n'existe pas)
24/09/2021, 15h59
Avi.Py
Citation:
Envoyé par foetus

En gros, tu as 2 choix :mrgreen:
*) Soit tu remplaces typedef float Element; par 1 structure.
Ensuite dans ton maillon, il faut savoir si tu stockes

1 element - à la création du maillon, tu passes 1 élément déjà créé : soit tu recopies les membres soit tu prends les pointeurs/ valeurs des membres.
1 element - à la création du maillon, tu passes chaque membre : soit tu les recopies soit tu prends leurs pointeurs/ valeurs.
1 pointeur d'élément - à la création du maillon, tu passes 1 élément déjà créé : soit tu prends cet élément, soit tu le recopies soit tu lui prends les pointeurs/ valeurs des membres (<- obliger de créer ton élément dans les 2 derniers cas)
1 pointeur d'élément - à la création du maillon, tu passes chaque membre : soit tu les recopies soit tu prends leurs pointeurs/ valeurs (<- obliger de créer ton élément dans les 2 cas)
Cette structure sera-t-elle correcte ?
Code:

1 2 3 4 5 6 typedef struct Element Element; struct Element { int nombre; Element *suivant; };
24/09/2021, 16h15
foetus
Citation:

Envoyé par Avi.Py

Cette structure sera-t-elle correcte ?

Non
Code:

1 2 3 4 5 typedef struct element { char* str01; size_t value; char* str02; } t_element;
Après, je ne sais pas du tout ce que doit contenir ta structure :koi:
- str01 : ‘’fonction#1’’, ‘’fonction#2’’, ’fonction#3’’
- value : 0x7F543210, 0x7F543220, 0x7F543230
- str02 : ‘’Ok’’, ‘’987654’’, ‘’123456’’
24/09/2021, 16h33
Avi.Py
Citation:
Envoyé par foetus

Non

Code:

1 2 3 4 5 typedef struct element { char* str01; size_t value; char* str02; } t_element;
Du coup je remplace mon typedef float Element par cette structure.

Mais ou est ce que je renseigne :
Citation:
str01 : ‘’fonction#1’’, ‘’fonction#2’’, ’fonction#3’’
value : 0x7F543210, 0x7F543220, 0x7F543230
str02 : ‘’Ok’’, ‘’987654’’, ‘’123456’’
Dans la structure toujours ?
24/09/2021, 16h46
foetus

Citation:

Envoyé par Avi.Py

Mais ou est ce que je renseigne

:mrgreen: c'est là que tu vas devoir revoir les cours (surtout les chaînes de caractères et les pointeurs) et tester/ planter pour comprendre.

Ce n'est pas pour rien que j'ai dit "recopier" et "prendre"
24/09/2021, 16h47
Avi.Py

Citation:

Envoyé par foetus

:mrgreen: c'est là que tu vas devoir revoir des cours (surtout les chaînes de caractères et les pointeurs) et tester/ planter pour comprendre.

Ce n'est pas pour rien que j'ai dit "recopier" et "prendre"

Okay pas de soucis je vais essayer d'avancer la dessus alors !

J'avoue que j'arrive pas trop à avancer ... J'ai essayé de modifier les pointeurs, prendre certains pointeurs après avoir recopier des éléments mais rien n'y fait ...

J'ai donc adopté la structure :
Code:

1 2 3 4 5 typedef struct element { char* str01; size_t value; char* str02; } t_element;
et modifié mon main.c tel que :
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 // // Fichier main.c // #include "pile.h" int main(int argc, char *argv[]) { struct element 1={"fonction#1’’, 0x7F543210, "Ok’’}; struct element 2={"fonction#2’’, 0x7F543220, "987654"}; struct element 3={"fonction#3’’, 0x7F543230, "123456’’}; Pile p; Element *elem; int estSommet=0; p=pileVide(); pileAjouter(p,1); pileAjouter(p,2); pileAjouter(p,3); while(pileLongueur(p)>0){ if(estSommet == 0){ printf("\nLe sommet de la pile est %0.2f\n\n",*pileSommet(p)); estSommet=1; } printf("| %0.2f |\n", *pileSommet(p)); printf("------------\n"); pileSupprimer(p); } return (0); }
Je suis totalement à côté de plaque ? Je n'y arrive vraiment pas ...

Finalement chacune des mes fonctions ne représente qu'une longue chaine de caractères, du moment que j'arrive a insérer toute la ligne <"fonction#1’’, 0x7F543210, "Ok’’> comme un élément dans la pile sa marche aussi, je ne suis donc pas obligé de déclarer une structure renseignant "#fonction1" comme str, 0745X... come un int et "Ok" comme un str. Si je peux empiler toute la ligne comme un gros str dans la pile ce serait plus simple je pense, mais la encore je n'y arrive toujours pas.