Discussion :

[Fabien25C]

Bonjour à tous!

Je suis actuellement en train de me lancer dans le dévellopement d'une calculatrice "évoluée", bon elle fait rien de spécial mais en fait j'ai recherché pas mal d'aide sur le net sur les calculatrices et je tombait à chaque fois sur une calculatrice toute simple du genre 4 + 5 = 9
En revanche, je souhaiterais pouvoir dévelloper une calculatrice permettant de calculer des expressions un peux plus complexe du genre: (4+2/2)*5

Mon problème:
J'ai un algorithme mais je n'arrive pas à le mettre en oeuvre
Je vous le propose et si vous pouviez me dire ce que vous en pensez, ou voir me donner des conseils ou dire que c'est de la daube je suis preneur :p

Algo:

création de 3 tableaux pour stocker parenthèses, signe, et valeure:

Code :

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

1
2
3
4
 
int elem_simples[500];
int nombres[500];
int operateur[500];

création de 4 variables désignant les caractères de la chaine:

Code :

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

1
2
3
4
5
 
int parenthese_ouvrante = 0;
int parenthese_fermante = 1;
int operateur = 2;
int nb = 3;

Ce qui nous donnerait:

( 2 + 3 ) * 5

elem_simples=>parenthese_ouvrante,nb,operateur,nb,parenthese_fermante,operateur,nb
nombres =>0,2,0,3,0,0,5
operateurs=>0,0,'+',0,0,'*',0



Le soucis maintenant est d'implémenter cet algorithme qui de plus permet juste de détecter de quoi est constituée l'expression donnée (qui sera donnée dans une chaine ASCII).

J'ai une esquisse de code, mais qui ne reprend pas cet algorithme:

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
 
#include <stdio.h>
#include <stdlib.h>
 
int numbers[10] = {0,1,2,3,4,5,6,7,8,9};
 
int main(void)
{
   int elem_simples[500];
   int nb_elem_simples;
   int nombres[500];
   int i;
   char operateurs[500];
 
   char parenthese_ouvrante, parenthese_fermante,operateur;
   int nb;
   char expression[128];
   gets(expression);
 
   parenthese_ouvrante = strchr(expression,'(');
 
   parenthese_fermante = strchr(expression,')');
 
   if(parenthese_ouvrante != NULL)
   {
       printf("Parenthese_ouvrante ");
 
       for(i=0;i<10;i++)
       {
          nb = strchr(expression,numbers[i]);
          if( nb != NULL)
          {
            printf("Chiffre ");
 
          }
       }
       if(parenthese_fermante != NULL)
       {
          printf("Parenthese fermante ");
 
       }
   }
 
 
   return 0;
}

Avec ce code, j'obtient un résultat du genre:

Code :

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

1
2
 
Parenthèse ouvrante Chiffre operateur Chiffre Parenthese fermante

pour une expression du type (5+2)


Bien sûr mes tableaux implémentés dans mon code ne servent à rien mais j'avais la flemme de les enlever car je ne trouve pas comment implémenter mon algorithme, si toutefois il est correct.

Merci d'avoir eu la patience de me lire
Bonne journée et si vous avez des conseils n'hésitez pas

Fabien

[Invité(e)]

Bonjour,

En effet, l'algorithme décrit et le code n'ont pas grand chose à voir...

Si on veux coder effectivement ton algorithme, on peut écrire :

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
 
#define parenthese_ouvrante 0
#define parenthese_fermante 1
#define operateur 2
#define nb 3
 
/**
 * Cette fonction remplit les trois tableaux à partir de l'expression donnée.
 * @param[in] expr: expression à analyser
 * @param[out] elts: tableau des types d'éléments
 * @param[out] nmbrs: tableau des nombres
 * @param[out] op: tableau des opérateur
 * @param[in] size: taille des tableaux.
 */
void parse(char *expr, int elts[], int nmbrs[], int op[], size_t size)
{
    size_t i;
    size_t len = strlen(expr);
    if(len > size) {
        len = size;
    }
    for(i = 0; i < len; ++i) {
        nmbrs[i] = 0;
        op[i] = 0;
        if('(' == expr[i]) {
            elts[i] = parenthese_ouvrante;
        } else if(')' == expr[i]) {
            elts[i] = parenthese_fermante;
        } else if(isdigit(expr[i]) {
            elts[i] = nb;
            nbrs[i] = expr[i];
        } else if(ispunct(expr[i]) {
            elts[i] = operateur;
            op[i] = expr[i];
        }
    }
}

je ne trouve pas comment implémenter mon algorithme, si toutefois il est correct.

Il n'est pas incorrect en soit, mais il n'est pas encore suffisamment abouti pour effectivement évaluer une expression arithmétique.

PS : ne pas utiliser gets, mais fgets à la place.

[Fabien25C]

Merci pour ton aide

Pour la suite de mon algorithme, une fois les valeures rangées dans chaque tableau, récupérer les nombres, analyser le signe, faire l'opération.
Sauf que le problème auquel je risque de me confronter, c'est les priorités, et peut être les différents caractères utilisable pour chaque opération (: ou / pour la division etc...)

Je vai étudier ton code merci beaucoup pour ton aide

[Fabien25C]

J'ai une chose que je ne comprend pas dans ton code, je me permet de poser des questions :p

Je comprend pas pourquoi mettre les tableaux en paramètres, car à l'appel, je voudrai analyser mon expression ( parse(expression); ) donc je ne comprend pas pourquoi mettre tous ces paramètres.

[Invité(e)]

Sauf que le problème auquel je risque de me confronter, c'est les priorités, et peut être les différents caractères utilisable pour chaque opération (: ou / pour la division etc...)

On peut utiliser des arbres pour faire ce genre de choses : http://recursivite.developpez.com/?page=page_8#LVII-C.

Je comprend pas pourquoi mettre les tableaux en paramètres, car à l'appel, je voudrai analyser mon expression ( parse(expression); ) donc je ne comprend pas pourquoi mettre tous ces paramètres.

Si j'ai mis les tableaux en paramètres, c'est pour bien séparer les taches : d'abord on analyse la chaine, puis derrière, une autre fonction peut mettre en page les résultats.

C'est plus simple de s'y retrouver avec plusieurs fonctions qui font chacune une tache bien définie plutôt qu'avec une gigantesque fonction qui fait tout.

Code :

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

1
2
3
4
5
6
7
8
9
10
#define SIZE 500
int elem_simples[SIZE];
int nombres[SIZE];
int operateur[SIZE];
 
parse(expr, elem_simples, nombres, operateur, SIZE);
 
affiche_nombres(nombres);
 
affiche_operateurs(operateur);

[Fabien25C]

décidément, je suis mal barré...
Je ne trouve vraiment pas l'algorithme pour réaliser mon programme
Si quelqu'un se sent d'attaque pour m'expliquer un peux comment je dois m'y prendre.
Merci d'avance