Discussion :

[pedro570]

Dans mon main, j'ai une chaine de caractère. Je veux mettre tous mes nombres dans la queue et tous les opérateurs dans la pile.
Pour la pile tout est ok, il n'y à aucun problème. Pour la queue ca se complique, a un moment j'arrive à avoir tous les nombres quand j'appelle cette fonction, ca les affiche sans problème ==>

Code :

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

puts(number);

Ca c'est ok et ca m'affiche bien ceci :
2
53
8
472
98
788

Je veux envoyer chacun de ces éléments grace a la fonction put_queue et ensuite afficher ma liste chainee en queue grace a la fonction view_queue mais ca ne m'affiche que des caractères spéciaux ... bizarre ... quelqu'un a t - il une solution svp ?

Voici le code en entier ==>

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
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
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
 
#include <stdlib.h>
 
struct pile
{
  char valeur;
  struct pile *new;
};
 
struct queue
{
  char *donnee;
  struct queue *suivant;
};
 
int put_queue(struct queue **p_file, char *donnee) // met des éléments dans la queue
{
  struct queue *p_nouveau = malloc(sizeof *p_nouveau);
  if (p_nouveau != NULL)
    {
      p_nouveau->suivant = NULL;
      p_nouveau->donnee = donnee;
      if (*p_file == NULL)
        {
          *p_file = p_nouveau;
        }
      else
        {
          struct queue *p_tmp = *p_file;
          while (p_tmp->suivant != NULL)
            {
              p_tmp = p_tmp->suivant;
            }
          p_tmp->suivant = p_nouveau;
        }
    }
  return (0);
}
 
int put_pile(struct pile **p_list, char valeur) // met des éléments dans la pile
{
  struct pile *new;
  new = malloc(sizeof(*new));
  if (new == NULL)
    return (1);
  new->valeur = valeur;
  new->new = *p_list;
  *p_list = new;
  return (0);
}
 
void view_queue(struct queue *p) // affiche la queue
{
  while (p != NULL)
    {
      puts(p->donnee);
      putchar('\n');
      p = p->suivant;
    }
}
 
void view_pile(struct pile *p) // affiche la pile
{
  while (p != NULL)
    {
      puts(p);
      putchar('\n');
      p = p->new;
    }
}
 
int stock(char *src) // des que j'ai un nombre, je le met dans la queue et dès que j'ai un opérateur je le met dans la pile
{
  struct pile *p_list;
  struct queue *q_list;
  char *number;
  char *operator;
  int i;
  int j;
 
  number = malloc(sizeof((number) + 1));
 
  p_list = NULL;
  q_list = NULL;
  i = 0;
  j = 0;
  while (src[i])
    {
      if (src[i] >= '0' && src[i] <= '9')
        {
          while (src[i] >= '0' && src[i] <= '9')
            {
              number[j] = src[i];
              j++;
              i++;
              number[j] = '\0';
            }
puts(number);
putchar('\n');
     put_queue(&q_list, number);
        }
 
      else if (src[i] == '*' || src[i] == '+' || src[i] == '-' || src[i] == '/' || src[i] == '%')
        {
 
         put_pile(&p_list, src[i]);                                                                                                                                                                        
          i++;
        }
  else
        {
          while (j >= 0)
            {
              number[j] = '\0';
              j--;
            }
          i++;
          j = 0;
        }
    }
    view_pile(p_list);
    view_queue(q_list);
  return (0);
}
 
int main(int arg, char **argv)
{
  char test[] = "2 * 53 + 8 - 472 + 98 - 788";
  stock(test);
  return (0);
}

[Bousk]

Bonsoir,

en général pour ajouter un élément à une liste, dont on connait la tête :
- on parcourt la liste en récupérant le suivant tant qu'il existe
- quand le suivant n'existe pas, on est arrivé à la fin de la liste
- on indique alors que le suivant est notre nouvel élément, qui est maintenant le dernier de la liste

D'ailleurs en lisant rapidement ton code, c'est ce qui est fait..!

Quel est donc le problème ?

[pedro570]

mon problème est le suivant, quand je teste mon code, c'est à dire quand j'essaye de mettre tous les nombres dans ma liste chainée en queue et que je décide d'afficher cette liste pour vérifier que tout s'est bien passé, et bien ca ne fonctionne pas.
C'est bizarre car je suis certain que (number) ne contient que des nombres puisque je décide d'afficher ces nombres à la liste 97. je décide donc d'appeller ma fonction "put_queue" et de lui donner en argument ces fameux nombres puis de lire ma liste chainée avec la fonction view_list.
Mais ca m'affiche des caractères qui n'ont rien à voir avec ce que j'ai demandé et je ne comprend vraiment pas pourquoi ... snif

[Steph_ng8]

Bonjour.

Avant tout, j'aimerais faire le point sur la fonction puts().
Elle écrit la chaîne de caractères passée en paramètre sur la sortie standard, mais elle ajoute également une nouvelle ligne.
Autrement dit, les deux lignes suivantes sont équivalentes :

Code :

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

1
2
puts(str);
printf("%s\n", str);

Ce n'est donc pas la peine de rajouter un putchar('\n'); après chaque affichage.
Sauf si tu veux absolument qu'il y ait une ligne vide entre les affichages ; mais dans ce cas, tu pourrais limiter les appels de fonction (ok, c'est de la micro-optimisation) :

Code :

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

printf("%s\n\n", str);

Attention, fputs() n'ajoute pas de nouvelle ligne après la chaîne.
Les deux lignes suivantes sont équivalentes :

Code :

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

1
2
fputs(str, fp);
fprintf(fp, "%s", str);

Toujours à propos de puts, il y a une petite erreur dans ton code :

Code :

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

1
2
3
4
5
6
7
8
9
10
#line 62
void view_pile(struct pile *p) // affiche la pile
{
  while (p != NULL)
    {
      puts(p);
      putchar('\n');
      p = p->new;
    }
}

p est du type struct pile *, et puts() attend un char *.
Je suppose que le problème est évident...

Sans doute voulais-tu écrire ceci :

Code :

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

puts(p->valeur);

Mais cela ne fonctionnera pas non plus, car struct pile::valeur est du type char.
Et

Code :

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

puts(&p->valeur);

est une très mauvaise idée, puisqu'on ne peut pas savoir quand viendra le premier octet assimilable à '\0'.

La solution est donc :

Code :

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

1
2
3
4
5
putchar(p->valeur);
putchar('\n');
 
/* ou en simplifié */
printf("%c\n", p->valeur);

Voilà qui devrait résoudre tes problèmes d'affichage.
Enfin normalement...


Je voudrais à présent faire une remarque à propos de ta « queue ».
Si j'ai bien compris, il s'agit d'implémenter une structure de données de type FIFO (First In First Out), ou « file » (d'attente) en français.
En général, on maintient deux pointeurs : un sur le premier élément (puisqu'on retire toujours au début de la file) et un sur le dernier (puisqu'on ajoute toujours à la fin de la file).

Ce second pointeur est très pratique lors de l'ajout, puisqu'il permet d'éviter de parcourir toute la file avant de déterminer l'endroit où insérer le nouvel élément.
Ce que tu as fait est tout à fait correct, mais plus il y aura d'éléments dans la file, plus l'ajout sera long.
À l'inverse, si tu conservais un pointeur sur le dernier élément, l'ajout serait constant.
Cela simplifiera de plus la procédure d'ajout.


Et maintenant, plongeons-nous un peu plus dans ton code.

Code :

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

1
2
#line 81
number = malloc(sizeof((number) + 1));

Je ne suis pas sûr que ce code fasse ce que tu attends.

• number est de type char * ;
• (number) est encore de type char * ;
• (number) + 1 est également de type char * ;
• sizeof((number) + 1) est équivalent à sizeof(char *) ;
• sizeof((number) + 1) est une expression constante et retourne la taille d'un pointeur (sur un caractère)

Je crois que tu aurais tout intérêt à déterminer une taille maximale suffisante pour stocker tous les nombres possibles pour ton application.
À partir de cette taille maximale, tu pourras allouer statiquement la mémoire nécessaire pour number plutôt que dynamiquement.

Code :

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

(src[i] >= '0' && src[i] <= '9')

Les fonctions du fichier d'en-tête « ctype.h » sont faites pour ça !
Tu peux remplacer ce double test par :

Code :

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

( isdigit(src[i]) )

Ce qui a l'avantage non négligeable de clarifier le code.


Je trouve que tu utilises un peu trop l'instruction :

Code :

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

number[j] = '\0';

Cela permet de s'assurer que l'on ne lira jamais de caractères non-affectés, certes ; mais si le reste du code est cohérent, cette garde est superflue, et ajoute beaucoup d'opérations inutiles.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
#line 89
      if ( isdigit(src[i]) )
        {
          while ( isdigit(src[i]) )
            {
              number[j] = src[i];
              j++;
              i++;
            }
          number[j] = '\0';
          (...)
        }

Ce code est amplement suffisant : on place un caractère nul dès que l'on sait que la chaîne de caractères est terminée.

De même :

Code :

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

1
2
3
4
5
6
#line 111
          while (j >= 0)
            {
              number[j] = '\0';
              j--;
            }

est totalement inutile, puisque de toute façon les caractères seront écrasés lors de la lecture du prochain nombre.


À part ça, comment se fait-il que tu ne libères jamais la mémoire allouée ?
Bon courage !

[pedro570]

Whaouuu ca c'est de la réponse Merci tout plein. Je fais analyser tout ça et je vais mettre à jour mon post quand tout sera parfaitement clair. Merci encore.

PS : je doute que je puisse "isdigit" car je fais ce programme pour réaliser un projet dans une école d'informatique (je dis pas le nom pour pas faire de pub Hahaha ) donc il y a certaines fonctionnalités que je n'ai pas encore le droit d'utiliser. Mais sinon pour le reste, c'est du tout bon

PS2 : concernant ta phrase

"Je crois que tu aurais tout intérêt à déterminer une taille maximale suffisante pour stocker tous les nombres possibles pour ton application."

Malheureusement je ne peux pas allouer de la mémoire statique car j'attends des nombres beaucoup beaucoup plus grands pour la suite et dont la taille m'est inconnue. Je vais donc devoir me retourner le cerveau dans tous les sens mais j'aime ça Haha.

[Steph_ng8]

je doute que je puisse "isdigit" car je fais ce programme pour réaliser un projet dans une école d'informatique (...) donc il y a certaines fonctionnalités que je n'ai pas encore le droit d'utiliser.

C'est toi qui vois.
Mais pour ta culture personnelle, n'hésite pas à te documenter sur les fonctions fournies par le fichier d'en-tête « ctype.h ».
Elle sont très utiles dans l'analyse caractère par caractères d'une chaîne, et sont plus parlantes qu'une succession de tests...

Malheureusement je ne peux pas allouer de la mémoire statique car j'attends des nombres beaucoup beaucoup plus grands pour la suite et dont la taille m'est inconnue.

Si tu peux déterminer la taille des nombres à lire à l'exécution, l'allocation dynamique est sûrement la meilleure solution.
Quitte à réallouer la mémoire si nécessaire.
Mais sinon, tu seras de toute façon obligé de « choisir » (arbitrairement) une taille.
Et dans ce cas, l'allocation statique est plus sûre.

Ceci dit, un moyen d'être sûr d'avoir suffisamment de place consiste à réserver autant de caractères qu'il y en a dans src...
(Du coup, l'allocation statique n'est pas possible.)