Reverse Polish Notation - Fabrique

Bonjour à tous,

Tout nouveau sur le forum, je programme depuis peu de temps : langage C depuis 1an et (C++,POO) depuis 3mois.

J'ai actuellement un projet à réaliser : la création d'une calculatrice à notation inverse polonaise. Pour ceux qui ne connaissent pas voilà de quoi vous faire rêver :

http://en.wikipedia.org/wiki/Reverse_Polish_notation

Pour ce qui est de ma calculatrice je vous ai joint un premier schéma UML (partiel pour vous faire comprendre mon idée)... Cependant mon soucis est que je ne suis pas encore bien à l'aise avec les DESIGN PATTERN et que donc j'aurai aimé votre expertise la dessus car j'ai deux trois idée de PATTERN qui pourrait être utiles mais je n'arrive pas à rendre ça concret...:cry:

Notamment une Fabrique :) :) mais comment faire???:aie:

[IMG]http://img15.hostingpics.net/pics/863330uml.jpg[/IMG]

Bien entendu si vous voulez plus de détails ou carrément le sujet du projet pour mieux comprendre le projet n'hésitez pas :ccool:

Bonjour,

pourquoi une fabrique ?
La réalisation d'une calculatrice en notation polonaise inversée est un exercice classique qui donne juste à réfléchir sur le parsing de chaîne de caractères. Généralement il s'agit d'un exercice réalisé en C.

Le moyen le plus simple qui me (re)vient à l'esprit est de réaliser un arbre, qui peut être représenté par cette struct

Code:

---

1 2 3 4 5 6 7

struct Operation { char operation; // +-/* double leftMember; // le membre gauche est un simple chiffre double rightMember; // le membre droit est un simple chiffre struct Operation* leftMemberOp; // le membre gauche est lui-même résultat d'une opération struct Operation* rightmemberOp; // le membre droit est lui-même résultat d'une opération };

---

qu'il suffira de parser et réaliser les opérations dans le bon ordre.

D'un autre côté, l'opération n'est pas ici "en RPN". Elle est stockée en arbre, et la RPN n'est qu'une représentation possible de cet arbre (en l’occurrence, le fruit d'un parcours postfixe).

Une opération stockée en RPN, c'est juste une liste, qui peut être évaluée (ou re-transformée en arbre) avec une simple pile.

Merci pour ta réponse Bousk !

Pour ce qui est de cette calculatrice RPN, la fabrique(abstract factory) me semble la bienvenue car je veux centraliser la création des objets tout en déléguant à chaque classe concernée la création de son Objet.

Voici un peu plus de détail sur le projet :


La calculatrice peut manier différents types de constante :

--Entière : suite de chiffres
--Rationnelle : deux entiers séparés par le caractère '/'
--Réelle : suite de chiffres pouvant accepter une virgule
--Complexe : constituée de deux constantes (Entière, Rationnelle ou Réelle)
séparées par le caractère '$'
--Expression : expression entourée du caractère ' à évaluer ultérieurement


Gestion des données:

--Les constantes sont stockées dans une pile au fur et à mesure de l'exécution
--Les X derniers éléments de la pile sont affichés à l'écran (où X est
paramétrable)


Évaluation d'une expression:

Une expression est composées d'opérateurs et de constantes séparés par des
espaces. Une expression est évaluée lorsque l'utilisateur appuie sur la touche
ENTRÉE. Dans le cas de la constante expression, (expression bornée par le
caractère ' et stockée dans la pile) l'évaluation s'opère à l'aide de l'opérateur EVAL.


Voici mon diagramme UML, un peu modifié :

http://img15.hostingpics.net/pics/430902UML.jpg

Je pense que tu te compliques un peu trop la vie pour les complexes. Tu devrais les intégrer au reste, faire que toute expression soit potentiellement complexe.

De manière similaire, les calculatrices simples n'ont pas de type "entier", par contre elles basent leur calcul à virgule flottante en décimal plutôt qu'en binaire IEEE 754.