Discussion :

[aminems]

bonsoir
svp j'ai un petit soucis avec un mini-projet , je dois lire une expression mathématique qui est sous la forme -par exemple- :
-123+5*(13e-0,5^6)
je dois pouvoir l'évaluer en utilisant la notation polonaise inverse.
jusque l'as c est ok , mon problème est que je ne trouve pas de solution pour pouvoir lire mes opérandes , (toute l'expression est de type string ).
l'idée qui m'est venu et d'utiliser un automate et de faire l'analyse lexicale , mais y as ici plus de 12 états et s'apparais plutôt trop compliqué .
y'a t ils pas d'autres solution?

a l aide svp.

[coyotte507]

Salut,

tu peux utiliser <sstream> ou <cstring> pour pouvoir lire des nombres d'une chaine de caractères.

Un exemple avec <vector> et <sstream>:

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
#include <sstream>
#include <vector>
#include <string>
#include <iostream>
 
using namespace std;
 
int main()
{
    /* L'expression à évaluer, et ce dans quoi on va la stocker */
    string chaine;
    istringstream item;
 
    cout << "Entrez une expression à évaluer: ";
    cin >> chaine;
 
    item.str(chaine);
 
    /* On stocke les nombres dans un vector, les opérateurs dans un autre */
    vector<int> nombres;
    vector<char> operateurs;
 
    char temp_op;
    int temp_nb;
 
    /* Quand il n'y aura plus rien à rentrer, la boucle sera arrêtée */
    while (1)
    {
        if (item >> temp_nb)
        {
            nombres.push_back(temp_nb);
        } else
        {
            item.clear(); //On rend possible de lire un opérateur, même si on n'a pas pu rentrer de nombres
        }
 
        if (item >> temp_op)
        {
            operateurs.push_back(temp_op);
        } else
        {
            break;
        }
    }
 
    cout << "Nombres:" << endl;
    for (vector<int>::iterator it = nombres.begin(); it != nombres.end(); ++it)
    {
        cout << *it << endl;
    }
 
    cout << "Operateurs:" << endl;
    for (vector<char>::iterator it = operateurs.begin(); it != operateurs.end(); ++it)
    {
        cout << *it << endl;
    }
 
    return 0;
}

Là, ça fait à peu près ce que tu veux mais pas complètement!
Par exemple, dans 13e-0,5 , il lit "13", "e", "0", ",", "5". (au lieu de "13", "e", "-0,5")

C'est un début d'idée, quoi!

[NewbiZ]

Nombreuses solutions:

1) Faire un analyseur syntaxique à la main. 12 états ca reste de l'ordre du raisonnable non ?

2) Utiliser un générateur d'analyseur syntaxique (lex/flex par exemple)

3) Un système à base d'expressions régulières (ce qui au final revient à faire un automate, mais c'est plus rapide à implémenter)

4) La solution proposée par coyotte507, qu'il faudrait un peu améliorer pour reconnaitre l'ordre des tokens.

[poukill]

Je viens tout juste d'en faire un avec des matrices!
1) boost::tokenizer pour découper la chaine
2) analyse basé sur un pattern Interprete
3) Génération des opérations basé sur une fabrique (avec Prototype, donc clonage)

Bon courage !

[aminems]

merci pour votre aide , je vais essayer avec boost.
et encore merci