Conversion vers la notation polonaise inversée (post-fixée)

**sperca** · 31/10/2008, 17h02

Bonjour,

Je suis entrain d'essayer de faire une calculatrice en C et j'aimerais utiliser la notation polonaise inversée pour gérer les parenthèses des différents calculs à effectuer. Pour le moment, j'essaye d'afficher sur la sortie la conversion.

Exemple : (4 + 3) * 5 -> 4 3 + 5 *

Voici mon code source :

conversion.c :

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
131
132
133
134
135
136
137
138
139
140
141
142
 
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
 
#include "conversion.h"
 
int
main(void) {
 
    struct pile operators;
    char string[SIZE];
 
    pile_initialisation(&operators);
    fgets(string, SIZE, stdin);
    conversion(string, &operators);
 
    return 0;
}
 
void
pile_initialisation(struct pile* operators) {
 
    int i = 0;
 
    for (i = 0; i < 100; i = i + 1) {
 
	(*operators).table[i] = '\0';
    }
    (*operators).top = 0;
}
 
/* Si c'est un chiffre, on l'affiche sur la sortie ;
 * Si c'est un operateur ou une parenthèse, on l'ajoute à la pile ;
 * Si c'est une parenthèse droite, on dépile jusqu'à la précédente parenthèse
 * gauche.
 * Sinon on avance de 1 (espaces tout ça...)
 */
 
void
conversion(const char* string, struct pile* operators) {
 
    int i = 0;
 
    while (string[i] != '\0') {
 
	if (isdigit(string[i])) {
 
	    printf("%d ", atoi(&string[i]));
	    i = next_no_digit(&string[i], i);
	}
	else if (isOperator(string[i])) {
 
	    add_operator_to_pile(string[i], operators);
	    i = i + 1;
	}
	else if (string[i] == ')') {
 
	    push_to_previous_parenthesis(operators);
	    i = i + 1;
	}
	else {
 
	    i = i + 1;
	}
    }
    push_pile_to_end(operators);
}
 
/* avance jusqu'au prochain signe different d'un chiffre... */
 
int
next_no_digit(const char* string, int i) {
 
    int j = 0;
 
    for (j = i + 1; !isdigit(string[j]); j = j + 1);
 
    return j;
}
 
int
isOperator(const char character) {
 
    int is = 0;
 
    switch (character) {
 
    case '+' :
	is = 1;
	break;
    case '-' :
	is = 1;
	break;
    case '*' :
	is = 1;
	break;
    case '/' :
	is = 1;
	break;
    case '(' :
	is = 1;
	break;
    default :
	is = 0;
    }
 
    return is;
}
 
void
add_operator_to_pile(const char operator, struct pile* operators) {
 
    (*operators).table[(*operators).top] = operator;
    (*operators).top = (*operators).top + 1;
}
 
/* depile jusqu'à la précédente parenthèse */
 
void
push_to_previous_parenthesis(struct pile* operators) {
 
    while ((*operators).table[(*operators).top - 1] != '(') {
 
	printf("%c ", (*operators).table[(*operators).top - 1]);
	(*operators).top = (*operators).top - 1;
    }
    (*operators).top = (*operators).top - 1;
}
 
/* on vide la pile operateurs, souvent en fin de calcul */
 
void
push_pile_to_end(struct pile* operators) {
 
    while ((*operators).top >= 1) {
 
	printf("%c ", (*operators).table[(*operators).top - 1]);
	(*operators).top = (*operators).top - 1;
    }
    (*operators).top = (*operators).top - 1;
}

conversion.h :

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
 
#ifndef CONVERSION_H
#define CONVERSION_H
 
#define SIZE 100
 
struct pile {
 
    char table[SIZE];
    int top;
};
 
void
conversion(const char* string, struct pile* operators);
 
int
next_no_digit(const char* string, int i);
 
int
isOperator(const char character);
 
void
add_operator_to_pile(const char operator, struct pile* operators);
 
void
push_to_previous_parenthesis(struct pile* operators);
 
void
pile_initialisation(struct pile* operators);
 
void
push_pile_to_end(struct pile* operators);
 
#endif

Pour le moment, le code ne fonctionne qu'à « moitié » et je ne comprends pas pourquoi. J'ai l'impression qu'il s'arrête à la parenthèse droite...

Donc si vous pouviez m'éclairer ;-).

Merci à vous.

Bye.

**Climoo** · 01/11/2008, 15h02

Jamais évident de comprendre tout un code comme ça de but en blanc... Il aurait été bien que tu parviennes à localiser plus ton problème. Ceci dit, tu codes assez proprement (comme un débutant en C

mais proprement), et donc j'arrive à comprendre certaines choses.
J'ai du mal à piger ton algo... Notamment :
dans ta fonction "conversion", tu écris :

Code :

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

1
2
3
4
5
6
 
if (isdigit(string[i])) {
 
	    printf("%d ", atoi(&string[i]));
	    i = next_no_digit(&string[i], i);
	}

(je passe sur le fait que tu affiches une adresse pour une raison inconnue).
Si on avait en entrée une chaine du type "4 + 3"
tu vas lire le '4', et tu vas chercher le prochain nombre, en l'occurence '3'. Mais le problème, c'est qu'au passage, le '+', tu ne l'auras pas lu, et donc il ne sera pas ajouté à ta pile "operators". Je me trompe? Ou alors ai-je mal compris ce que tu voulais faire?

J'ai aussi cru comprendre que tu affichais le résultat, plus ou moins au fur et a mesure de la lecture (fonctions push_pile_to_end et push_to_previous_parenthesis). C'est surement pas une bonne idée, vaudrait mieux stocker le résultat dans une nouvelle chaine, et lafficher ensuite.
Je pense que tu devrais revoir ton algo (pas évident je le conçois), a mon avis utiliser la récursivité ici me semble approprié, car ta chaine de caractere est en fait :
expression= expression operande expression
ou
expression= (expression)
ou
expression= nombre

**sperca** · 01/11/2008, 17h08

Re,

Déjà merci à toi pour ta réponse.

Ceci dit, tu codes assez proprement (comme un débutant en C mais proprement), et donc j'arrive à comprendre certaines choses.

Si tu pouvais m'expliquer les points du code qui ne vont pas pour le rendre plus propre voire plus "pro" je prends ;-).

Alors ensuite pour l'algorithme, je lis la chaine caractère par caractère, si je rencontre un chiffre je l'affiche sur la sortie (l'écran ici), si je rencontre un opérateur, je l'ajoute à la pile operators, si je rencontre une parenthèse droite je dépile jusqu'à la précédente parenthèse gauche, sinon j'avance de une case dans le tableau (gestion des espaces tout ça...).

Je suis absolument d'accord pour le côté récursif mais là je voulais faire un truc rapide histoire de voir si c'était faisable.

Dans le cas (4 + 3) * 5, dans un premier temps je lis, '(', je l'ajoute à la pile, puis '4', je l'affiche sur al sortie, puis '+' je l'ajoute à la pile, puis le '3' même traitement que pour le '4'. Maintenant je rencontre la prenthèse ')' donc je dépile la pile opérators sans lire la parenthèse gauche. Donc à ce moment là je devrais avoir ceci à l'écran : 4 3 + ce que j'ai donc jusque là je suppose que tout va bien.

Or vu que je ne suis pas arrivé au caractère de fin de chaine '\0', je ne comprends pas pourquoi je n'ajoute pas le '*' à la pile et que je n'affiche pas le 5 sur la sortie...

Tu me dis que je ne lirai pas le '+' or je pense que si vu que la fonction next_no_digit me permet d'avancer le curseur jusqu'au prochain caractère différent d'un chiffre donc à partir de là je passe forcément sur le '+' (j'ai vérifié en affichant le contenu de la pile au fur et à mesure).

Donc en fait j'aimerais savoir pourquoi il ne prends pas en compte le "* 5".

Merci à vous.

Bye

**Climoo** · 01/11/2008, 18h20

Ok ! Oui en effet tu as raison, j'avais mal regardé ta fonction, et tu prends bien le '+' en compte. Mea culpa...

En ce qui concerne les choses qui montrent que tu es débutant (pas vraiment important, mais comme tu es curieux, je vais te dire ce que j'ai repéré), il ya déjà ton "case" dans :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
switch(caractere){
case '+' :
	is = 1;
	break;
    case '-' :
	is = 1;
	break;
    case '*' :
	is = 1;
	break;
    case '/' :
<...>
}

Tu peux très bien écrire (c'est moins lourd)

Code :

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

1
2
3
4
5
6
7
8
9
 
switch( character) {
case '+' :
case '-' :
case '*' :
case '(' :
case '/' : is=1; break;
default : is=0;
}

Normalement, ca marche... Mais, vu les circonstances, j'aurais fait (enfin c'est plus une question de goût sur ce coup là) :

Code :

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

1
2
 
is = ( (character == '+') || (character=='-') || (character=='*') <...> )

C'est pas tellement plus efficace, juste un peu plus lisible.
Ensuite, autre remarque, ceci :

Code :

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

1
2
 
(*operators).top = (*operators).top - 1;

Tu peux remplacer les "(*X)." par "X->" , qui est un truc spécial pour les pointeurs vers des structures. Ensuite, "X=X-1" sera quasi toujours remplacé
par "X--", ou "--X" (ya une difference entre les deux, je te laisse chercher sur ce site, mais en loccurence pour toi ca revient au même). Ce qui donne :

Code :

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

1
2
 
operators->top--;

Un peu plus sympa à lire tu trouves pas ?
Bon aller, un dernier, mais celui là, c'est seulement si tu te sens à l'aise avec le C (et que t'aimes bien les trucs un peu moche comme moi^^, j'avais des profs qui supportaient pas ce genre de trucs)

Code :

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

1
2
 
while (string[i] != '\0')

peut s'écrire :

Code :

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

1
2
 
while (string[i])

Je te laisse chercher pourquoi ca fonctionne très bien en C... Après t'as dautres lignes que tu peux simplifier selon ces méthodes, je te laisse regarder si t'as envie^^.

Mais bon, là n'est pas la question, revenons en à nos moutons.
Je reregarde ta fonction conversion, et je ne vois pas pourquoi pas il ne te prend pas en compte ton *5. L'erreur ne vient probablement pas de là, mais pour être sur, je vérifierai quand même que tu as bien "lu" ta chaine au départ dans ton main (j'utilise jamais fgets, mais bon je dis pas que ca marche pas!)
Ensuite, si ca marche toujours pas, je commencerai pas faire des affichages, notamment dans la partie du if de "conversion", ou tu détectes si string[i]==')' . Ou plus généralement, afficher tous les caractères que tu lis. Comment ca se fait qu'il arrive sortir de ta boucle, si théoriquement il n'y a pas de '/0'...
Et aussi, ca résoudra surement pas le problème, mais plutot que de faire "i= i+1" ou "i = next_no_digit(&string[i], i)", je ferai une seule fonction, a appelé à chaque passage de la boucle, tu gagneras en simplicite et lisibilité

Code :

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

1
2
3
4
5
6
7
 
int next_char(char *s, int i){
  char *p=s;
  while (*p && (!is_operator(*p)) && (!is_digit(*p)) )
     p++;
   return p-s+i; 
}

Je teste pas (je peux pas), à toi de le faire... Bon courage.

Remarque pour le poste d'avant: j'ai fait une boulette aussi en disant que tu affichais une addresse mémoire, j'avais mal regardé

! Décidément....

**sperca** · 01/11/2008, 20h43

Merci à toi ;-).

Voilà j'ai résolu mon problème de départ (pas totalement par exemple pour 5*(4+3), je n'obtiens pas encore la forme que je veux mais je verrai ça plus tard en exploitant la récursivité).

Juste mon code ressemble à ceci (j'ai pas appliqué tous les raccourcis, car c'est juste pour "voir").

conversion.c

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
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
 
#include "conversion.h"
 
int
main(void) {
 
    struct stack operators;
    char string[SIZE];
 
    stack_initialisation(&operators);
    fgets(string, SIZE, stdin);
    conversion(string, &operators);
 
    return 0;
}
 
void
stack_initialisation(struct stack* operators) {
 
    int i = 0;
 
    for (i = 0; i < 100; i = i + 1) {
 
	(*operators).table[i] = '\0';
    }
    (*operators).top = 0;
}
 
void
conversion(const char* string, struct stack* operators) {
 
    int i = 0;
 
    while (string[i] != '\0') {
 
	if (isdigit(string[i])) {
 
	    printf("%d", atoi(&string[i]));
	    i = next_no_digit(&string[i], i);
	}
	else {
 
	    if (is_operator(string[i])) {
 
		add_operator_to_stack(string[i], operators);
	    }
	    else if (string[i] == ')') {
 
		push_to_previous_parenthesis(operators);
	    }
	    i++;
	}
    }
    push_stack_to_end(operators);
}
 
int
next_no_digit(const char* string, int i) {
 
    char *p = string;
 
    while (*p && (!is_operator(*p)) && isdigit(*p)) 
	p++;
 
    return p - string + i;
}
 
int
is_operator(const char character) {
 
    int is = 0;
 
    switch (character) {
 
    case '+' :
    case '-' :
    case '*' :
    case '/' :
    case '(' : 
	is = 1;
	break;
    default :
	is = 0;
    }
 
    return is;
}
 
void
add_operator_to_stack(const char operator, struct stack* operators) {
 
    (*operators).table[(*operators).top] = operator;
    (*operators).top = (*operators).top + 1;
}
 
void
push_to_previous_parenthesis(struct stack* operators) {
 
    while ((*operators).table[(*operators).top - 1] != '(') {
 
	printf("%c", (*operators).table[(*operators).top - 1]);
	(*operators).top = (*operators).top - 1;
    }
    (*operators).top = (*operators).top - 1;
}
 
void
push_stack_to_end(struct stack* operators) {
 
    while ((*operators).top >= 1) {
 
	if ((*operators).table[(*operators).top - 1] == '(') {
 
	    break;
	}
	printf("%c", (*operators).table[(*operators).top - 1]);
	(*operators).top = (*operators).top - 1;
    }
    (*operators).top = (*operators).top - 1;
}

Et j'obtiens ce warning à la compilation :

conversion.c: In function ‘next_no_digit’:
conversion.c:63: warning: initialization discards qualifiers from pointer target type

Et je ne comprends pas ce qu'il signifie.

Voilà merci à vous.

Bye.

**orfix** · 01/11/2008, 22h18

Envoyé par sperca

Et j'obtiens ce warning à la compilation :

c'est tout, en es-tu sûr ?

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
 
sperca.c: Dans la fonction «next_no_digit» :
sperca.c:60: attention : initialization discards qualifiers from pointer target type
sperca.c: Dans la fonction «conversion» :
sperca.c:105: attention : passing argument 2 of «add_operator_to_stack» from incompatible pointer type
sperca.c:109: attention : passing argument 1 of «push_to_previous_parenthesis» from incompatible pointer type
sperca.c:114: attention : passing argument 1 of «push_stack_to_end» from incompatible pointer type
sperca.c: Dans la fonction «next_no_digit» :
sperca.c:119: attention : initialization discards qualifiers from pointer target type
sperca.c: Dans la fonction «conversion» :
sperca.c:164: attention : passing argument 2 of «add_operator_to_stack» from incompatible pointer type
sperca.c:168: attention : passing argument 1 of «push_to_previous_parenthesis» from incompatible pointer type
sperca.c:173: attention : passing argument 1 of «push_stack_to_end» from incompatible pointer type
sperca.c: Dans la fonction «next_no_digit» :
sperca.c:178: attention : initialization discards qualifiers from pointer target type
sperca.c: Dans la fonction «stack_initialisation» :
sperca.c:236: attention : «main» is normally a non-static function
sperca.c: Dans la fonction «main» :
sperca.c:239: erreur: «SIZE» undeclared (first use in this function)
sperca.c:239: erreur: (Each undeclared identifier is reported only once
sperca.c:239: erreur: for each function it appears in.)
sperca.c:239: attention : unused variable «string»
sperca.c: Dans la fonction «stack_initialisation» :
sperca.c:246: erreur: expected declaration or statement at end of input
sperca.c: Dans la fonction «conversion» :
sperca.c:246: erreur: expected declaration or statement at end of input
sperca.c: Dans la fonction «next_no_digit» :
sperca.c:246: erreur: expected declaration or statement at end of input
sperca.c: Dans la fonction «is_operator» :
sperca.c:246: erreur: expected declaration or statement at end of input
sperca.c: Dans la fonction «stack_initialisation» :
sperca.c:246: erreur: expected declaration or statement at end of input
sperca.c: Dans la fonction «conversion» :
sperca.c:246: erreur: expected declaration or statement at end of input
sperca.c: Dans la fonction «next_no_digit» :
sperca.c:246: erreur: expected declaration or statement at end of input
sperca.c: Dans la fonction «is_operator» :
sperca.c:246: erreur: expected declaration or statement at end of input
sperca.c: Hors de toute fonction :
sperca.c:130: attention : unused parameter «operators»
sperca.c:129: attention : unused parameter «string»
sperca.c:129: attention : unused parameter «operators»
sperca.c: Dans la fonction «next_no_digit» :
sperca.c:246: attention : control reaches end of non-void function
sperca.c: Hors de toute fonction :
sperca.c:128: attention : unused parameter «string»
sperca.c:128: attention : unused parameter «i»
sperca.c: Dans la fonction «is_operator» :
sperca.c:246: attention : control reaches end of non-void function
sperca.c: Hors de toute fonction :
sperca.c:127: attention : unused parameter «character»
sperca.c:71: attention : unused parameter «operators»
sperca.c:70: attention : unused parameter «string»
sperca.c:70: attention : unused parameter «operators»
sperca.c: Dans la fonction «next_no_digit» :
sperca.c:246: attention : control reaches end of non-void function
sperca.c: Hors de toute fonction :
sperca.c:69: attention : unused parameter «string»
sperca.c:69: attention : unused parameter «i»
sperca.c: Dans la fonction «is_operator» :
sperca.c:246: attention : control reaches end of non-void function
sperca.c: Hors de toute fonction :
sperca.c:68: attention : unused parameter «character»

Envoyé par sperca

Et j'obtiens ce warning à la compilation :

conversion.c: In function ‘next_no_digit’:
conversion.c:63: warning: initialization discards qualifiers from pointer target type

ce warning est dû au fait que tu affectes un 'const char *' à un 'char *', tu devrais normalement déclarer 'p' comme étant un 'const char *' .

**sperca** · 02/11/2008, 11h57

Alors merci pour la précision ;-) c'est corrigé et je n'ai plus de warnings ni d'erreurs.

Comment t'as fait pour obtenir tous ces messages ? Je compile avec les options -Wall -ansi et je n'ai aucun messages.

Merci à vous.

Bye

Edit : tu obtiens peut-être tous ces warnings car j'ai modifié le header ar rapport à la dernière version de conversion.c...

Je redonne le code final ici :

conversion.c :

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
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
 
#include "conversion.h"
 
int
main(void) {
 
    struct stack operators;
    char string[SIZE];
 
    stack_initialisation(&operators);
    fgets(string, SIZE, stdin);
    conversion(string, &operators);
 
    return 0;
}
 
void
stack_initialisation(struct stack* operators) {
 
    int i = 0;
 
    for (i = 0; i < 100; i = i + 1) {
 
	(*operators).table[i] = '\0';
    }
    (*operators).top = 0;
}
 
void
conversion(const char* string, struct stack* operators) {
 
    int i = 0;
 
    while (string[i] != '\0') {
 
	if (isdigit(string[i])) {
 
	    printf("%d", atoi(&string[i]));
	    i = next_no_digit(&string[i], i);
	}
	else {
 
	    if (is_operator(string[i])) {
 
		add_operator_to_stack(string[i], operators);
	    }
	    else if (string[i] == ')') {
 
		push_to_previous_parenthesis(operators);
	    }
	    i++;
	}
    }
    push_stack_to_end(operators);
}
 
int
next_no_digit(const char* string, int i) {
 
    const char *p = string;
 
    while (*p && (!is_operator(*p)) && isdigit(*p)) 
	p++;
 
    return p - string + i;
}
 
int
is_operator(const char character) {
 
    int is = 0;
 
    switch (character) {
 
    case '+' :
    case '-' :
    case '*' :
    case '/' :
    case '(' : 
	is = 1;
	break;
    default :
	is = 0;
    }
 
    return is;
}
 
void
add_operator_to_stack(const char operator, struct stack* operators) {
 
    (*operators).table[(*operators).top] = operator;
    (*operators).top = (*operators).top + 1;
}
 
void
push_to_previous_parenthesis(struct stack* operators) {
 
    while ((*operators).table[(*operators).top - 1] != '(') {
 
	printf("%c", (*operators).table[(*operators).top - 1]);
	(*operators).top = (*operators).top - 1;
    }
    (*operators).top = (*operators).top - 1;
}
 
void
push_stack_to_end(struct stack* operators) {
 
    while ((*operators).top >= 1) {
 
	if ((*operators).table[(*operators).top - 1] == '(') {
 
	    break;
	}
	printf("%c", (*operators).table[(*operators).top - 1]);
	(*operators).top = (*operators).top - 1;
    }
    (*operators).top = (*operators).top - 1;
}

conversion.h

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
#ifndef CONVERSION_H
#define CONVERSION_H
 
#define SIZE 100
 
struct stack {
 
    char table[SIZE];
    int top;
};
 
void
conversion(const char* string, struct stack* operators);
 
int
next_no_digit(const char* string, int i);
 
int
is_operator(const char character);
 
void
add_operator_to_stack(const char operator, struct stack* operators);
 
void
push_to_previous_parenthesis(struct stack* operators);
 
void
stack_initialisation(struct stack* operators);
 
void
push_stack_to_end(struct stack* operators);
 
#endif

Voilà.

Conversion vers la notation polonaise inversée (post-fixée)

C

Discussions similaires

Partager

Partager