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.)

[pedro570]

voila, je viens de changer les quelques petits détails dont tu m'as parlé.

Le plus important étant donc cette ligne :

Code :

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

1
2
 
number = malloc(sizeof((number) + 1));

que j'ai transformé en

Code :

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

1
2
 
number = malloc(sizeof((src) + 1));

Ce qui me laisse déjà une bonne marge, en effet.

J'ai mis des free à la fin pour libérer la mémoire alloué mais dans un autre fichier, histoire de ne pas faire tous les changements d'un coup et de ne pas perdre de vue où se situe mon erreur. Idem pour les \0 superflus. Mais je tiens quand même encore à te remercier de toutes les trouvailles que tu as su déceler, j'apprend beaucoup de mes erreurs. Voici donc mon code légèrement modifié, pas le plus optim' donc mais en tenant compte de mes erreurs les plus flagrantes ==>

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
 
#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)
    {
      putchar(p->valeur);
      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((src) + 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); // mes nombres s'affichent toujours les uns à la suite des autres sans problèmes
                    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);
}

Et là ... miracle ... j'en suis au même point qu'avant xD lol.
C'est à dire que j'obtiens en réponse ceci :
788
788
788
788
788
788

En clair, ma fonction view_list me dit que j'ai 6 fois le nombre 788 dans ma queue. Autrement dit, il y à 6 nombres, et donc j'ai mis 6 fois le dernier nombre dans ma liste chainée. Alors soit c'est la fonction view_queue qui ne marche pas. Ca serait trèèèèèès bizarre. Soit c'est la fonction put_queue. mais lorsque je demande d'afficher les nombres (ligne 98) avant de les mettre dans ma queue, ceux - ci s'affichent sans problèmes.
J'obtiens bien :
2
53
8
472
98
788

Très étrange ...

[Bousk]

Bonsoir,

pour réaliser un malloc de N éléments, il convient de faire

Code :

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

void* malloc(n * sizeof(element) )

Il convient aussi de caster le type de retour.

Pour récupérer la longueur d'une chaîne, voir

Code :

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

int strlen(const char*)

Enfin ton problème est que tu utilises une seule variable number* dans ton code.
Quand tu stockes la donnée dans queue, tu stockes une adresse et non une chaîne.
L'adresse est celle de number.
Puisque l'adresse utilisée est unique, tous les éléments de la queue ont la même adresse en donnée, et son contenu est le dernier nombre trouvé dans ton script.

Modifie ta chaîne initiale en la faisant terminer par autre chose qu'un nombre et plus aucun nombre ne sera affiché.

Pense aussi à libérer la mémoire que tu alloues

[pedro570]

Modifie ta chaîne initiale en la faisant terminer par autre chose qu'un nombre et plus aucun nombre ne sera affiché.

En effet, je viens de modifier mon main de départ qui était

Code :

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

1
2
 
char test[] = "2 * 53 + 8 - 472 + 98 - 788"

en quelque chose qui ressemble à ceci :

Code :

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

1
2
 
char test[] = "2 * 53 + 8 - 472 + 98 - 788!"

En oui tu as raison, plus rien n'est affiché du coup. Je vais relire ce que tu viens de me dire plusieurs fois car je ne suis pas sur d'avoir tout compris mais je vais cogiter là - dessus. Merci pour le tuyau ^^

[Steph_ng8]

Désolé, à force de faire du C++, j'en ai oublié qu'il n'y a pas de « vrai » type « chaîne de caractères » en C...
Et puis j'étais focalisé sur les autres problèmes...

Le fichier d'en-tête « string.h » comporte pas mal de fonctions de manipulation de chaînes de caractères.
Comme strlen(), par exemple.
Mais si tu ne peux pas les utiliser, à l'instar de « ctype.h », il te faudra les réécrire.

Entre nous, écrire une fonction qui calcule la longueur d'une chaîne ou qui copie le contenu d'une chaîne dans une autre, ce n'est pas très compliqué.
D'ailleurs, ce sont des exercices classiques pour vérifier que l'on a bien compris comment fonctionne le type « chaîne de caractères » en C...
N'hésite pas à aller consulter la F.A.Q. à ce sujet, tu y trouveras des informations utiles si tu ne maîtrises pas.
(Tiens, j'ai comme l'impression d'avoir laissé échapper un indice... )


En passant, il y a un autre moyen de faire, qui évite de dupliquer des bouts de chaîne.
Au lieu de stocker des « chaînes de caractères » dans la file, tu pourrais enregistrer un pointeur vers le bon endroit dans la chaîne de départ et une longueur de sous-chaîne ; par contre, il ne faut pas modifier la chaîne d'origine entre le début de l'analyse et la fin du traitement.

Cette méthode implique de bien comprendre le mécanisme des pointeurs et des chaînes de caractères ; et selon ce qui est fait par la suite, elle n'est pas forcément applicable.
Je ne voudrais pas t'embrouiller, alors concentre-toi d'abord sur ce que tu as déjà commencé, et sur les indications que nous t'avons données.
Quand tu auras bien compris comment faire de la manière que tu es parti, et si tu as un peu de temps devant toi, tu pourras essayer de voir comment implémenter cette méthode ; et si tu as des questions, nous y répondrons.

[Sve@r]

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 struct pile
{
  char valeur;
  struct pile *new;
};
 
struct queue
{
  char *donnee;
  struct queue *suivant;
};

Salut

Déjà ce serait pas mal que tu utilises les conventions en nommant tes structures s_qqchose. Ca éviterait ensuite, en milieu de code, de se demander si "queue" est un type ou une variable.
Ensuite, les typedef c'est pas mal. Ca évite de retaper "struct" à chaque fois.

Par ailleurs il y a très peu de différence entre ta struct pile et ta struct queue. Aucune en fait. Bref tu peux en supprimer une des deux.

De plus, en dehors des exos, une structure de liste chainée ne se justifie que si les éléments sont triés ce qui oblige parfois à des insertions en milieu de liste. En effet, dans le cas d'un tableau, une insertion en milieu nécessite un décalage de tous les éléments suivants alors qu'avec une liste chainée, une insertion en milieu de liste ne nécessite qu'une modification de 2 pointeurs. C'est un grand avantage qui compense la perte des avantages liés aux tableaux.
Maintenant, si l'insertion doit se faire uniquement en début ou en fin, alors un tableau est largement suffisant. On ne fait qu'ajouter en fin de tableau (quitte à opérer une inversion lors de l'affichage pour simuler une insertion en début de tableau) et on réalloue si on a besoin de mémoire. Bref c'est bête de perdre les avantages liés aux tableaux pour utiliser une structure inutile.

Code :

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

int put_queue(struct queue **p_file, char *donnee) // met des éléments dans la queue

Tu remarques que tu as mis un double pointeur. Parce qu'il peut arriver que le premier élément de ta liste soit modifié ce qui t'oblige à passer l'adresse de ce premier élément qui est déjà un pointeur.
Or si tu encapsulais ta liste dans un type apte à la manipuler, tu serais débarrassé de ce souci. Ce type contiendrait l'adresse de ton premier élément (plus d'autres trucs si tu le juges utile) et chaque fonction devant manipuler ta liste ne recevrait que l'adresse de ce type. Bref le double étoile serait masqué par l'indirection structX->structY.

Exemple

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
 typedef struct s_elem {
	char *donnee;
	struct s_elem *new;
} t_elem;
 
typedef struct {
	t_elem *first;
	ulong nb;
} t_liste;
 
void initListe(t_liste *liste)
{
	liste->first=NULL;
	liste->nb=0;
}
 
void viewListe(t_liste *liste) // affiche la liste
{
	t_elem *elem;
	for (elem=liste->first; elem != NULL; elem=elem->new)
	{
		puts(elem->donnee);
		putchar('\n');
	}
}
 
int main()
{
	t_liste liste;
	initListe(&liste);
	...
	viewListe(&liste);
}

Comme je le dis souvent, on peut tenir une chemise par le col mais on s'en sort mieux si on la met sur un cintre...

[Steph_ng8]

Par ailleurs il y a très peu de différence entre ta struct pile et ta struct queue. Aucune en fait. Bref tu peux en supprimer une des deux.

Ah non, là je proteste.
Les éléments de la « pile » sont des caractères, alors que les éléments de la « queue » sont des chaînes de caractères (enfin du moins, des pointeurs sur caractère).
C'est tout à fait différent.


...

Comme je le dis souvent, on peut tenir une chemise par le col mais on s'en sort mieux si on la met sur un cintre...

Ha ha, sympa cette phrase, je retiens...

[pedro570]

ouahhhh je suis en train de me prendre la tete je ne vous raconte meme pas lol. J'espère vous répondre vite et ne pas avoir trop l'air d'un idiot ^^

[Sve@r]

Ah non, là je proteste.
Les éléments de la « pile » sont des caractères, alors que les éléments de la « queue » sont des chaînes de caractères (enfin du moins, des pointeurs sur caractère).
C'est tout à fait différent.

J'étais certain que qqun viendrait faire la remarque sans trop réfléchir sur ce que j'avais dit et sur ce que cela entraine.
Mais qu'est-ce qui t'empêche d'aller stocker dans la queue la chaine de caractères "+" ou "-" ou "*" ou "/" ? Est-ce réellement différent que de stocker la chaine "2" ou "53" ou "8" ou "472" ou "98" ou "788" ???

[Steph_ng8]

J'étais certain que qqun viendrait faire la remarque sans trop réfléchir sur ce que j'avais dit et sur ce que cela entraine.
Mais qu'est-ce qui t'empêche d'aller stocker dans la queue la chaine de caractères "+" ou "-" ou "*" ou "/" ? Est-ce réellement différent que de stocker la chaine "2" ou "53" ou "8" ou "472" ou "98" ou "788" ???

Roh... Si on ne peut même plus plaisanter...
Le smiley et les points de suspension étaient là pour indiquer que je n'étais pas sérieux, mais bon tant pis...

Rassure-toi, j'avais parfaitement compris ce que tu sous-entendais.
M'enfin, au moins maintenant, pour ceux qui n'avaient pas compris, c'est clair...

[Sve@r]

Roh... Si on ne peut même plus plaisanter...
Le smiley et les points de suspension étaient là pour indiquer que je n'étais pas sérieux, mais bon tant pis...

Aïe, désolé de n'avoir pas compris. Le pb du smiley "roll" c'est qu'il lève les yeux au ciel comme s'il était blasé de la stupidité de celui à qui il s'adresse. Et donc ben en fait c'est pas un smiley dédié à l'humour...

[Steph_ng8]

Arf oui, on peut le prendre comme ça...
Bon, le principal c'est que le quiproquo soit résolu...