Voila, je commence le C depuis tres peu de temps, d'ailleurs je commence la programmation tout court
 
 
J'aimerai pour le moment creer une mini calculatrice : operations de base a savoir + - * / et bien sur la possibilite de mettre des parentheses...
 
Il faut aussi evidement qu'elle gere les priorites des operations !!!
Alors deja je pensai faire un programme qui recoit comme argument une chaine de caracteres... Donc pour commencer il faut parcourir cette chaine de caracteres.
 
Je pensais ensuite faire ca avec 2 listes chainees : une qui empile les nombres, et une qui empile les operateurs, avec leurs priorites ! (et faire augmenter la priorite a chaque parenthese ouvrante rencontree, et inversement pour les parentheses fermantes. Seulement je debute et j'ai beaucoup de mal avec les listes chainees   , et donc je voulais savoir si c'est realisable comme ca, ou si il y a un moyen plus simple.    
 
C'est vrai que c'est pas super dur les listes chainees mais au debut on a bien du mal a s'en servir (moi en tout cas et je sais que je suis pas le seul).
 
 
bah voila le probleme, j'attend maintenant vos reponses  

pas infaisable mais assez galère
moi perso je serai plutôt pour un développement en C et lex&yacc

 
Pardonne mon ignorence mais... c'est quoi  

Tu peux aussi utiliser les arbres : un arbre d'expression qui représente les operateurs et les operandes de l'expression de manière hièrarchique

 
Dans les cours que j'ai trouver ils parlent pas des arbres, c'est vraiment des cours de bases alors j'ai pas grand chose dedans. Je vais essayer de trouver quelque chose la dessus.
 
merci pour les conseils

un arbre c'est une liste chaînée avec plusieurs fils

lex c'est un analyseur lexical et yacc pour l'analyse grammaticale
en gros tu parses avec lex et tu vérifie la grammaire avec yacc, ensuite ca te génère un code source en C et tu fais ce que tu veux avec
c'est très puissant, et ca t'évite toute les peines qu'on endure pour parser du texte
 
si t'est assez curieuse, regarde lex & yacc (ou flex & bison) tu verras une fois que le principe est compris que ta calculatrice se fait très rapidement et avec très peu de risques d'erreurs

Tu implémentes une machine abstraite à pile qui va évaluer ton expression de manière postfixe (on applique chaque opérateur aux 2 opérandes qui le precedent).
 
Ton expression : ((10 + 2) * 4) / (42 + 24)
Son arbre :
 
            /
     |             |
     *             +
   |   |         |    |
   +   4         42   24
 |   |
10   2
En postfixe (on parcourt d'abord le sous arbre gauche de maniere postfixe, puis le sous arbre gauche et pour finir la racine) cette expression sera évaluée comme çà (((10 2 +) 4 *) (42 24 +) / )
On parcoure l'expression de gauche à droite et on empile les valeurs jusqu'à trouver un operateur, on depile les opérandes requises pour l'operateur, le resultat est à son tour empilé. On repete l'operation sur toute la longueur de l'expression dont la valeur finale est la seule restante sur la pile.

Oui manatane c'est comme ca que je l'imaginais, mais si tu fais comme expression : 2 + 3 * 2 , il va commencer par faire 2 + 3, et ensuite * 2 non ? donc le resultat sera faux, selon la priorite des operations il devrait faire 3 * 2 et ensuite + 2... ca donne pas du tout le meme resultat au final.

http://www.info.ucl.ac.be/notes_de [...] nting.html

ok merci...  
 
 
Bon bah alors je vais essayer comme ca...
Si je m'en sort pas j'essayerai d'une autre methode toute facon
 
merci a tous

Ouais bah finalement niveau code c'est pas tres facile pour une debutante.

bongour

Une fois que tu as converti la form infixe à la forme postfix il ne reste plus qu'à évaluer. Il faut toujours une pile ou tu empiles si tu as un nombre.
Si tu as un opérateur tu dépiles deux fois pour faire l'opération que tu réempiles.
 
Et voila le tour est joué
 
 
Edit : j'avais pas vu que c'était expliqué dans le lien.

J'y arrive deja pas... la programmation c'est peut etre pas pour moi on dirait  
 
Faire ca ca veut juste dire que j'interverti les caracteres de la chaine selon certaines conditions ?
 

Je garde cette etape pour plus tard j'en suis pas encore la.    
 

Je suppose que c'est valable uniquement si l'expression a ete convertie en forme postfix ?    
 

Pas dans mon cas... suis-je pas assez futee pour esperer realiser ce programme... j'ai des doutes la  

Tu as une expression, il te faut
1) la parser pour en récupérer les diffèrents composants (avec strtok() pour faire simple)
2) la convertir d'une notation infixe->postfixe avec l'algo de l'aiguillage (en meme temps que tu recuperes les composants de l'expression si possible)
3) insérer l'expression décomposée dans un arbre
4) l'évaluer avec une machine abstraite à pile
 
Tu as des exemples de listes chainées, piles, arbres binaires, arbre d'expresssion (très bien foutus) ici http://examples.oreilly.com/masteralgoc/
 
Enfin si tu débutes en programmation c'est quand meme un truc plutot ardu que tu entreprends...
Fait en sorte de toujours travailler au plus haut niveau d'abstraction et de tester le plus frequemment possible tes algos (puisque les structures de données te sont fournis par les exemples du bouquin oreilly).

manatane j'ai l'impression que tu compliques un peu.
Pour moi il n'y a rien besoin de parser tout se fait uniquement à l'aide de piles.
 
Helena, j'ai les codes sous les yeux et je comprends c'est donc que c'est pas dur.
 
Voici l'algo à peu pres pour faire avec des lettres
 
on inititialise et déclare une pile (pile), une chaine vide (post) et un caractère (op)
pour i:=1 à longueur(exp)
faire
    si exp[i] est une lettre
        on concatène exp[i] à post
    ou alors exp[i] == ')'
         on dépile et on place le caractère dans op
         on concatène op à post
    ou alors exp[i] != '('
         empiler[i] dans p
retourner post
 
 
edit : c'est la version ou tout est parenthésé.
La version qui marche à tous les coups et nettement plus longue

En fait je sais pas si ca va vous aider, mais le but c'est de recoder la fonction bc en quelque sorte, je sais pas si ca vous dit quelque chose. (sans prendre en compte l'histoire des bases d'entrees et sorties pour le moment)
 
Donc je crois qu'en fait c'est la version longue de ton truc.
 
merci quand meme, je reessayerai dans 3 ans

Je t'assure que y'en a pas pour beaucoup de lignes de codes. Je pense que en 100 lignes tu dois pouvoir faire qqchose qui fait infixe -> postfix -> resultat (en ayant deja une implémentation des piles)

expression prefix = plus dur mais tellement plus interessant

Heu si tu debutes vraiment en C tout ca va etre bien trop complexe j imagine.
 
Si tu veux coder une calculatrice qui marche et qui est tres facile a coder essaye de faire "une calculatrice polonaise inversée".
 
C est un grand classique en prog. C est un bon exo car comme c est géré par une pile (First In First Out), ca t apprend en meme temps a coder toutes les petites fonctions de manipulation de pile (empiler, depiler, vider etc ...).
 
Pour debuter c est deja tres sympa et ca te prendra la tete quelques heures.

C'est bien de ca que l'on parle depuis le début (on appele la notation postfix la notation polonaise inversée)
 

Scusez j avais pas tout lu en effet

La meilleur facon de faire tout ca est de tout stocké dans une liste chainé puis de piller les opérateurs et les calcul pour gérer les paranthèses une fonction récursive qui va faire le calcul avec chiffres et opérande ( le resultat de la paranthèses)
 
Syruis

Voila une fonction qui convertit de infixe à postfixe des chaines contenant des lettres.
 

 
Elle converti une expression "infixe" (expression où l'opérateur binaire se trouve entre les arguments style "2 + 3" ) en expression "postfixe" (expression où l'opérateur binaire se trouve après les arguments style "2 3 +" )
 
Tu connais "google" ? C'est un truc à la mode sur le net qui te permet de trouver certaines réponses par toi-même...

C'te vieux déterrage de topic

 
Pour ce genre de dessins, les balises 'fixed' sont le bienvenues...
 
Son arbre :

Punaise, ça devient infernal. Un \, on le voit pas, 2 \, on en voit 2 (\\)... Que faire ?