je vous presente vite fais le but de ce topic.
le prog suivant sert a évaluer une chaine contenant une operation en ecriture prefixée
exemple: " + 3 5" => 3+5 => 8
" + 3 * 5 8" => ( 5*8)+3 => 43
voila je pense que ca sufit a comprendre comment ça fonctionne.

je vous donne un fichier zip contenant les fichiers sources et un executable d´exemple.
http://www.info.univ-angeangers.fr/pub/letouzey/pro.zip

le fichier pile.h implementes les fonctions de base sur les piles.
le fichier operation.h defini les operation possible dans ma caculette.
et prefixe.c permet d´evaluer une expression prefixée
c´est surtout sur l´ecriture de ce dernier que je voudrait que vous me donniez vos avis.
( efficacitée des fct chose inutiles manque de lisibilité)
j´ai essayé de metre autant de commentaire que possible mais si un truc vous semble peu clair dites le moi.

voila et merci.

Oh ! Une calculatrice en polonaise
( tien d´ailleurs, pourquoi ne pas ajouter un support de la notation polonaise inverse ? )

Sinon ca tourne bien, le seul petit repproche que j´émettrai concerne le relative manque de lisibilité de certaines parties du code...
Sinon tu devrais employer un fichier . c couplé à chaque . h : tu mets les prototypes, structures etc... dans les . h et leur implémentation dans le . c associé ( qui porte le même nom quoi, pour faire lisible) : cela éviterait d´avoir un . c pour le fichier contenant le main et le reste en . h

• notation polonaise

>>( tien d´ailleurs, pourquoi ne pas ajouter un support de la notation polonaise inverse ? )

quoi est-ce????

ben le contraire, une écriture post fixé :

3 5 8 * + => 4+5*6 ( avec les bonnes priorités)

la notation post fixé est bcp plus facile à implémenter informatiquement, c´est come ça que marchait les première calculatrice, mais même des machine comme la TI-89 fonctionne comme ça en interne.

Le seul avantage d´une notation pré-fixé par rapport à post-fixé, c´est que c´est adapté à créer des arbres pour l´évaluation si par exemple tu veux transformer ton programme en programme pour faire du calcul formel ( mais c´est faisable aussi en post-fixé, mais moins facilement).

Il faut noter aussi que pour un humain le post fixé est plus facile à lire et écrire.

3 5 8 * + => 3+5*8
j´ai pas fait attention à ce que j´écrivais...

j´ai regardé ton code, il est bien, mais y´a juste un truc que je trouve vraiment moche c´est ta gestion des racines carré et carré.
c´est pas du tout du tout évolutif. déjà mettre des opérateurs en 2 mots c´est pas propre, mais la manière dont tu les lis est bizarre.

j´aurais pensé à un truc qui lis mots après mots c´est à dire d´un espace au suivant et qui " comprend" ce qu´il vient de lire lorsqu´il a fini. manifestement ce n´est pas ce que tu fait avec ces opérateurs dont tu devine ce qu´ils sont au début du mots ( enfin à la fin) à la limite avec ton system on pourrait remplacer racine carrée par e et carré par é si un jour tu rajoutte les variables, et que tu veux faire une variable e et bien tu programme sera perdu, d´où l´interet delire le mot en entier avant de décide de quoi il s´agit.

utilise plutot des formule consacré comme sqrt pour la racine et l´opérateur ^ pour l´élévation à la puissance.

>dnob700

ta derniere remarque est assez pertinente mais je fais cette calculette dans le cadre d´un exo de cours et les seuls operateurs demandés sont + - * / " carré" et " racine carrée"
ecrit de cette maniere et pas autrement.

j´avais bien penssé a faire " carré"="c"
et " racine carrée"="r" pour pouvoir plus simplement ajouter des truc comme puissance ou autre...
mais bon je fais ce qui est demandé.

j´ai deja rajouté la petite fleche qui pointe sur les erreurs et je sais pas si mon prof(assez peu ouvert sur les originalités) va aimer...

>mais la manière dont tu les lis est bizarre.

je les lis a partir de la fin. en remontant les caracteres 1 par 1.
( idem pour la fct lit_entierfin)
ceci me permet d´utiliser les pile pour stocker les operandes au lieu d´utiliser un arbre.

-vous allez me dire pq les piles plutot que les arbres??
->parce que j´ai aussi une calculatrice postfixe a faire et dans celle ci il est plus simple d´utiliser les piles.
et donc ca me permet de garder les meme fct de calcul ( calcul.h) et de ne pas refaire toute l´implémentation des arbres.

en fait j´ai juste a changer ( lit_entierfin par un truc du genre lit_entier debut)
et le reste du prog devrait ( a 1 ou 2 truc pres) s´adapter

la difference entre une expression postfixe et une notation prefixe:
( pour mon prog)
dans la version prefixe on lit les elt de l´expression dans ce sens < - en partant de la fin.
dans la version postfixe on lit les elt de l´expression dans ce sens -> en partant u debut.

et zut j´ai encore oublier un truc...

>>Sinon tu devrais employer un fichier . c couplé à chaque . h : tu mets les prototypes, structures etc... dans les . h et leur implémentation dans le . c associé ( qui porte le même nom quoi, pour faire lisible) : cela éviterait d´avoir un . c pour le fichier contenant le main et le reste en . h

tu veux dire avoir les fichiers suivants:
prefixe.c
calcul.c//declaration des fct de calcul
calcul.h//enumeration des fct de calcul
pile.c//declaration des fct sur les piles
pile.h//enumeration des fct sur les piles.