Discussion :

[Avi.Py]

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 :

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
//   	
// 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 :

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
//   	
// 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 :

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
//   	
// 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 :

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
#   	
# 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 :

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

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 !

[foetus]

En gros, tu as 2 choix
*) 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)

[Avi.Py]

En gros, tu as 2 choix
*) 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 :

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

1
2
3
4
5
6
typedef struct Element Element;
struct Element
{
    int nombre;
    Element *suivant;
};

[foetus]

Cette structure sera-t-elle correcte ?

Non

Code :

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

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

• str01 : ‘’fonction#1’’, ‘’fonction#2’’, ’fonction#3’’
• value : 0x7F543210, 0x7F543220, 0x7F543230
• str02 : ‘’Ok’’, ‘’987654’’, ‘’123456’’

[Avi.Py]

Non

Code :

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

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 :

• str01 : ‘’fonction#1’’, ‘’fonction#2’’, ’fonction#3’’
• value : 0x7F543210, 0x7F543220, 0x7F543230
• str02 : ‘’Ok’’, ‘’987654’’, ‘’123456’’

Dans la structure toujours ?

[foetus]

Mais ou est ce que je renseigne

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"