//   	
// 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);

//   	
// 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;
}

//   	
// 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);

}



#   	
# 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) *~[/CODE]


J'obtient donc avec ce code : 

//   	
// Résultat
//   	

Le sommet de la pile est 3.00

| 3.00 |
----------
| 2.00 |
----------
| 1.00 |
---------

-
Edité par Avi.Py 25 septembre 2021 à 19:06:24

Donc tu veux sauvegarder ; une chaîne de caractère, un entier (32 bits) et une chaîne de caractère. 

Et bien moi je mettrais ces trois éléments dans une structure.

Et ta pile au lieu de sauvegarder un flaot, elle sauvegardera un élément du type de cette structure.

rouIoude a écrit:

Donc tu veux sauvegarder ; une chaîne de caractère, un entier (32 bits) et une chaîne de caractère. 

Et bien moi je mettrais ces trois éléments dans une structure.

Et ta pile au lieu de sauvegarder un flaot, elle sauvegardera un élément du type de cette structure.

Une structure correspondant donc à :

typedef struct element {
    char* str01;
    size_t value;
    char* str02;
} t_element;

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 unique é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.

-
Edité par Avi.Py 25 septembre 2021 à 17:39:43

-
Edité par edgarjacobs 25 septembre 2021 à 17:48:40

Si tu met tout dans une chaîne de caractère, pour l'utilisation des données extraite de ta pile tu devras aussi les extraire de ta chaîne de caractère ce qui est encore moins simple.

Avi.Py a écrit:

 mais la encore je n'y arrive toujours pas.

edgarjacobs a écrit:

Si j'étais mauvais langue , je dirais que cette discussion a déjà eu lieu sur dvp, et que la dernière réponse du Avi.Py est un copié collé de réponse qui ont été faites suer ce forum.Mais je ne suis pas une mauvaise langue, je barre donc ce que j'ai écrit.

Oui j'ai du mal et je poste mon problème sur différent forum où est le mal ? Je cherche juste à comprendre, si j'ai pas le droit de repost mon problème sur différent forum montrer moi la règle et je supprimerai ce topic pas de soucis.

rouIoude a écrit:

On voudrait bien t'aider, mais on ne sait pas ce qui te bloque ? Poste ton code, on pourra probablement te guider dans tes erreurs.

J'ai renseigné mes différents fichier (pile.h,pile.c,main.c,Makefile) dans mon tout premier message. Ce que je n'arrive pas à faire c'est ajouter un element de format (’fonction#3’’, 0x7F543230, ‘’123456’’) a la place du nombre 3. J'ai changé la structure d'Element mais je n'ai pas réussi à intégrer cet structure d'élément pour pouvoir intégrer correctement un element de ce format la dans la pile.

-
Edité par Avi.Py 25 septembre 2021 à 18:50:43

Bonjour,

quand on part d'une implémentation comme :

...

typedef float Element;
 
struct SCellule {
     Element info;
     struct SCellule *psuiv;
};
 
typedef struct SCellule *Cellule;
 
struct SPile{
      struct SCellule *sommet;
      int nbElements;
};

...

pour une pile dont les éléments manipulés (de type Element) sont des floats (cf le typedef) et qu'on veut adapter ce code (et non scripte surtout avec un e final) pour manipuler des éléments qui sont composés d'une chaîne, une valeur entière et une autre chaîne (en lieu et place d'un float) , alors le plus simple est de bien définir Element, comme par exemple

typedef struct {
    char *first_string;
    int integer_value;
    char *second_string;
} Element;

Ça permet une réutilisation simple du source, enfin si on comprend le code source évidemment.

Moi je n'y vois pas de problème tant que tu tiens compte des suggestions et que tu postes le même code partout.
As-tu modifié ton code depuis le début de ce sujet?
Que veux-tu dire par «je n'y arrive pas»?
Testes une fonction à la fois. Fais des ajouter suivi des affichages.

Testes si afficher une pile vide fonctionne.
Si ça marche, fais des suppressions suivi d'un affichage à chaque fois jusqu'à ce que ta pile soit vide.

-
Edité par PierrotLeFou 25 septembre 2021 à 18:51:59

White Crow a écrit:

pour une pile dont les éléments manipulés (de type Element) sont des floats (cf le typedef) et qu'on veut adapter ce code (et non scripte surtout avec un e final) pour manipuler des éléments qui sont composés d'une chaîne, une valeur entière et une autre chaîne (en lieu et place d'un float) , alors le plus simple est de bien définir Element, comme par exemple

1 2 3 4 5

typedef struct { char *first_string; int integer_value; char *second_string; } Element;

Ça permet une réutilisation simple du source, enfin si on comprend le code source évidemment.

Cela est bien équivalent à la structure que j'ai renseigné dans la réponse à rouloude non ?

PierreLeFou a écrit:

Moi je n'y vois pas de problème tant que tu tiens compte des suggestions et que tu postes le même code partout.
As-tu modifié ton code depuis le début de ce sujet?

Oui j'ai modifié mon code depuis le début du sujet, j'ai changé la strucure d'element (dans le fichier pile.h) en passant de :

typedef float Element;

à

1 2 3 4 5

typedef struct element { char* str01; size_t value; char* str02; } t_element;

-
Edité par Avi.Py 25 septembre 2021 à 19:01:35

Je pense que la meilleure façon de l'aider et surtout de lui conseiller de :

• comprendre le source avant de le modifier ;
• le modifier correctement avec un minimum d'efforts ;
• et surtout écrire des fonctions, ne pas caster les mallocs, bien indenter le programme, etc.

Écrire des fonctions est primordial.

Edit: et évidemment de ne pas cacher des pointeurs dans des typedef !

-
Edité par White Crow 25 septembre 2021 à 18:53:52