Bonjour a tous,
 
Voila j'ai un projet a rendre  , il consiste a crée une calculatrice en C je vous réecrit le sujet:
                                       
                                                         
                                               
" Specifier puis programmer en C une fonction pour evaluer, en calculs sur les entiers, une expression arithmetique. Celle-ci se presente sous la forme d'une suite d'entiers naturels sur un seul chiffre decimal, d'operateurs binaires parmi = - * / et des parentheses ( et ). La suite est supposée correctement et complétement parenthésée. Tous les caractéres sont entrés successivement au clavier. On definira cette evaluation de maniere recursive sur les entrées, puis iterative, en utilisant une seule PILE contenant operandes et operateurs codés de maniere convenable. Mais on ne programmera qu'une seule version. On suppose connues les operations usuelles sur les caractéres. "
 
J'espere que vous pourrez m'apporter votre aide en me pistant car je ne sais ni par où commencer ni quoi faire.
De plus je débute dans la programmation en C.
 
Je vous remercie d'avance.

 
 
Tu dois évaluer des expressions à deux opérandes de ce style "2 + 3" ou "6 * 7".
Donc tu dois créer une fonction qui :

• recherche le premier opérande
• recherche l'opérateur
• recherche le second opérande

et renvoie le résultat.
 
Si jamais ta fonction arrive sur une parenthèse, style "2 * (3 + 4)", alors elle s'appelle elle-même pour la partie "3 + 4" (récursivité) et renvoie le résultat "7" à la fonction appelante qui n'a plus qu'à l'utiliser comme un opérande normal.
Avec ce système, tu peux analyser l'expression la plus complexe qui soit.
 
En ce qui concerne le mécanisme de pile, il te faut utiliser une structure contenant

• opérande
• opérateur

Tu analyses l'expression comme dans le paragraphe précédent en remplissant ta structure. Puis, si tu trouves une parenthèse ouvrante, alors tu empiles (mise en attente) ta structure incomplètement évaluée dans une pile (tableau) et tu recommences avec une structure neuve pour évaluer l'expression entre parenthèses, etc etc.
Dès que l'expression entre parenthèses est évaluée, tu rappelles la dernière structure empilée et tu utilises le résultat de l'expression que tu viens d'évaluer dans le calcul qui avait été mis en attente.
 
Beaucoup de rigueur, travailler aussi avec un papier et un crayon pour dessiner le contenu de ta mémoire et de ta pile, et ça roule.

merci bcp svear ,ouais jai avancé je ten remercie.ta pas un exemple dimplémentation en c ,pour voir a quoi ca ressemble de ton coté.

comme structure, j'aurais bien vu un arbre. Ca s'y prête bien pour ce genre de calcul...

Salut camarade,
       tu  peux essaiyer ce code (~_~) !
 
**********************************************************************************************************
#include<stdio.h>
#include<stdlib.h>
 
   int addition(int x, int y);
   int soustraction(int x, int y);
   int division(int x, int y);
   int multiplication(int x, int y);
   
  int main()
 
  {
   int color;
   int resultat,a,x,y;
   color = system (" color b" );
 
   printf("\t\t\t*****************************************\n" );
   printf("\t\t\t**             MODE BASE               **\n" );
   printf("\t\t\t*****************************************\n\n\n" );
 
   printf("\t\t\t****************MENU*********************\n" );
   printf("\t\t\t*    0 Quitter                          *\n" );
   printf("\t\t\t*    1 MULTIPLICATION                   *\n" );
   printf("\t\t\t*    2 DIVISION                         *\n" );
   printf("\t\t\t*    3 SOMME                            *\n" );
   printf("\t\t\t*    4 SOUSTRACTION                     *\n" );
   printf("\t\t\t*****************************************\n\n\n" );
 
   printf("Entrer votre choix:" );
   scanf("%d",&a);
 
     
     
     if(a==3)
     {
      printf("\n\n****SOMME*****\n\n" );
      printf("Entrer premier nombre :" );
      scanf("%d",&x);
      printf("Entrer second nombre :" );
      scanf("%d",&y);
      resultat=addition(x,y);
      printf("%d + %d = %d\n",x,y, resultat);
       
 
     }
     if(a==4)
     {
      printf("\n\n****SOUSTRACTION*****\n\n" );
      printf("Entrer premier nombre :" );
      scanf("%d",&x);
      printf("Entrer second nombre :" );
      scanf("%d",&y);
      resultat=soustraction(x,y);
      printf("%d - %d = %d\n",x,y, resultat);
       
 
     }
      if(a==1)
     {
      printf("\n\n****MULTIPLICATION*****\n\n" );
      printf("Entrer premier nombre :" );
      scanf("%d",&x);
      printf("Entrer second nombre :" );
      scanf("%d",&y);
      resultat=multiplication(x,y);
      printf("%d * %d = %d\n",x,y, resultat);
       
 
     }
       if(a==2)
     {
      printf("\n\n****DIVISION*****\n\n" );
      printf("Entrer premier nombre :" );
      scanf("%d",&x);
      printf("Entrer second nombre :" );
      scanf("%d",&y);
      resultat=division(x,y);
      printf("%d / %d = %d\n",x,y, resultat);
       
     }
 
   return 0;
  }
       
   
    int addition(int x, int y)
    {
     int resultat;
     resultat = x+y;
     return resultat;
    }
     
    int soustraction(int x, int y)
    {
     int resultat;
     resultat = x-y;
     return resultat;
    }
    int division(int x, int y)
     {
     int resultat;
     resultat = x/y;
     return resultat;
    }
    int multiplication(int x, int y)
     {
     int resultat;
     resultat = x*y;
     return resultat;
    }
**********************************************************************************************************
   
 
 
   
 
 
 
 
 

 
"tu peux me montrer comment tu as fait, que je puisse pomper intégralement et ne pas le faire moi-même ?"
 

 
C'est moche.
 

  int addition(int x, int y);  
   int soustraction(int x, int y);  
   int division(int x, int y);  
   int multiplication(int x, int y);
 
ca sert a quoi ?
a la limite pour faire des wrappers et obtenir un pointeur d'un type de fonction int (*operateur_binaire)(int a, int b); j'aurais compris ... mais la ?

scanf c trop bo >_<

voui les erreurs sont bien gérées, tout ca.

faudrait tout refaire en ASM multimédia sur un kernel windows

 
0.5/20
 
pour l'effort fourni.

la suite de if n'est pas mal aussi...

 
tout à fait.
N'oubliez pas d'envoyer vos CV anonymes après !

Balises code please!

Non.
 
http://mapage.noos.fr/emdel/notes.htm#saisie
http://mapage.noos.fr/emdel/notes.htm#fichiers

je veux realiser l'application suivante dans le langage C en exploitant les forces de ce langage
pour exprimer au mieux votre programme (e.g. l'arithmetique sur les pointeurs si c'est approprie).
L'application est une petite calculatrice a precision illimitee. Il faut representer des nombres
entiers avec des listes de chires, de telle facon que la calculatrice supporte des nombres de longueurs
arbitraires. Le programme doit implanter les operations +, - et * ainsi que des variables representees
par une lettre minuscule a..z.
Chaque expression est sur une ligne et la calculatrice attends l'entree en imprimant \>" en guise
d'incitateur. Apres la  n de ligne le programme imprime le resultat sur une nouvelle ligne. Les
expressions sont sous forme postxe, donc une interaction valide avec le programme pourrait ^etre:
> 10 15 + 2 *
50
Pour l'aectation d'une variable, il faut utiliser:
<expression> =<var>
par exemple pour assigner 100 a la variable 'a':
> 100 =a
100
j'arrive pas a resourdre mon probleme

Salut,
 
Tout d'abord, évite le déterrage, le sujet date de 2005.    
Ensuite, où est ton problème exactement ?
Tout ton sujet n'est pour le moment qu'un copier/coller de l'énoncé en question, mais il faudrait peut-être nous donner un premier jet de ta part, parce qu'on ne va pas faire tout à ta place.
D'après ce que je vois, les calculs à rentrer sont en NPI (Notation Polonaise Inversée). Je te conseille donc dans un premier temps de réaliser un mini-parser mathématique, sans te soucier des variables. Celles-ci viendront ensuite.
Je te propose donc d'implémenter une pile. Voici un algorithme possible. Tu lis ton calcul caractère par caractère :
- Si le caractère est un nombre, tu l'empiles.
- Si le caractère est un opérateur (+ / *) tu dépiles deux nombres et tu effectues ton opération sur ceux-ci. Résultat que tu stockes dans une variable, que tu gardes à chaque tour de boucle.
 
A toi ensuite de te renseigner si il y a des notions que tu ne saisis pas.