Pile et listes chaînées

Bonjour Theo_0055,

Une "pile" peut être implémentée de plusieurs façons en C.

Si tu disposes d'un code que tu as réalisé et qui gère une pile pour un caractère, il est possible que ton code puisse être adapté pour gérer des chaînes de caractères.

Utilises-tu une liste chaînée, un simple tableau, autre chose ?

Dal

J’utilise une liste chaîné et une pile

Les caractères et chaînes de caractère sont dans ma liste chaîné et je veux empiler cela sur ma pile

typedef struct Element Element;
struct Element{
    int nombre;
    Element *suivant;
};

typedef struct Pile Pile;
struct Pile{
    Element *sommet;
};

void empiler_char(Pile *pile,char&  carac){
   Element *nouveau = malloc(sizeof(*nouveau));
    if (pile == NULL || nouveau == NULL)
        exit(EXIT_FAILURE);
        
    nouveau->nombre = carac;
    nouveau->suivant = pile->sommet;
    pile->sommet = nouveau;
}

Maintenant,je veux créer une fonction void empiler_chaineCarac qui empile une chaine de caractere

J’ai une petite piste esceque on doit faire tant que on a pas fini de parcourir la chaîné de caractère,on ajoute le caractère dans la pile en faisant appel à empiler_char?

Salut Theo_0055,

OK, 2 remarques sur ton code avant d'entrer dans le vif du sujet : ton membre nombre est de type int, alors que tu veux y stocker des char ; deuxièmement dans ton prototype

void empiler_char(Pile *pile,char&  carac)

la partie

char&  carac

n'est pas du C (cela ressemble à une référence C++).

Tu peux rendre ton code plus générique en mettant le type géré dans un typedef.

Ton idée dans ce que tu postes est de stocker la donnée dans le maillon, mais en utilisant directement le type char dans les paramètres de ta fonction. En faisant cela, ton code d'ajout devient spécifique aux données traitées.

Une autre approche serait de rendre ton code plus générique pour que ta pile puisse traiter n'importe quel type de données avec un minimum de changements.

typedef char Donnee; 

typedef struct Element Element;
struct Element{
    Donnee donnee;
    Element *suivant;
};

void empiler_donnee(Pile *pile, Donnee donnee){
    if (pile == NULL)
        exit(EXIT_FAILURE);
    Element *nouveau = malloc(sizeof(*nouveau));
    if (nouveau == NULL)
        exit(EXIT_FAILURE);
        
    nouveau->donnee = donnee;
    nouveau->suivant = pile->sommet;
    pile->sommet = nouveau;
}

Ce code devrait gérer une pile de char en copiant le char passé en tant que type Donnee dans la pile.

Ensuite, il suffit de changer

typedef char Donnee; 

en

typedef char * Donnee; 

pour gérer une liste de pointeurs sur char où tu stockes des pointeurs sur char passés à la fonction empiler_donnees().

Cela fonctionne car, dans

empiler_donnee

, l'opérateur d'affectation dans

nouveau->donnee = donnee;

va simplement affecter un pointeur.

Si tu veux que ta liste gère une copie des données passées, stockée sous la forme de tableau de char dans la pile, alors tu peux le faire aussi, mais il faut ruser car l'opérateur d'affectation

=

ne permet pas l'affectation de types tableaux en langage C. En revanche, il peut gérer les struct. Donc, en rusant, tu peux réutiliser le même code en changeant ton type Donnee comme ceci :

#define MAX_LEN 500
typedef struct Donnee Donnee; 
struct Donnee {
    char str[MAX_LEN];
};

Dans

empiler_donnee()

, l'opérateur d'affectation à la ligne

nouveau->donnee = donnee;

va alors copier le contenu de la struct (en faisant une opération équivalente à un memcpy()).

1.Pour le char& carac en fait c’était une erreur de frappe c’était char carac tout court sans &

2.Si j’ai bien compris
typedef char Donnee donnee =définition du type Donnee (qui est un char)

3.votre dernier Donnee il est censé gérer les chaînes de caractères c’est ça?

4.J’ai essayé plusieurs fois d’écrire un code pour gérer n’importe quel type de Donnee (char,int,double,..) mais le problème je sais pas comment m’y prendre
Car créer à chaque fois une fonction qui dépile int,une autre des char.. c’est un peu répétitif et j’aimerais créer une seule qui gère tous les types

Voilà une illustration d'une struct comprenant une union et un membre permettant de conserver le type de la donnée, en utilisant un enum pour codifier les types.

#include <stdlib.h>

enum type_donnee { CHAR, INT, DOUBLE, PCHAR, MAX_TYPES };
union val {
        char c;
        int i;
        double d;
        char * s;
};

typedef struct Donnee Donnee;
struct Donnee {
        union val val;
        enum type_donnee type;
};

typedef struct Element Element;
struct Element{
        Donnee donnee;
        Element *suivant;
};

typedef struct Pile Pile;
struct Pile{
        Element *sommet;
};

Pile * init_pile(void) {
        Pile * p = malloc(sizeof(*p));
        p->sommet = NULL;
        return p;
}

void empiler_donnee(Pile *pile, Donnee donnee){
        if (pile == NULL)
                exit(EXIT_FAILURE);
        Element *nouveau = malloc(sizeof(*nouveau));
        if (nouveau == NULL)
                exit(EXIT_FAILURE);

        nouveau->donnee = donnee;
        nouveau->suivant = pile->sommet;
        pile->sommet = nouveau;
}

int main(void) {
        Pile * p = init_pile();

        Donnee donnee;

        donnee.val.c = 'A'; donnee.type = CHAR;
        empiler_donnee(p, donnee);

        donnee.val.i = 123; donnee.type = INT;
        empiler_donnee(p, donnee);

        donnee.val.d = 123.45; donnee.type = DOUBLE;
        empiler_donnee(p, donnee);

        donnee.val.s = "saperlipopette"; donnee.type = PCHAR;
        empiler_donnee(p, donnee);

        return 0;
}

Lorsque tu dépiles, tu consultes d'abord le type récupéré, et, en fonction du type, tu accèdes à la valeur récupérée à travers l'union récupérée.

Dal

Merci je vais essayer de comprendre et je vous refait signe