Travaux Pratiques n°4

Classe, méthodes et champs

Vous devez avoir à présent une idée assez précise de la façon dont va fonctionner cette calculette.

Nous allons la créer sous la forme d'une classe donc le nom sera pcalc.

Création d'une pile

Nous avons vu que nous allons avoir besoin d'une pile pour stocker les opérandes et les résultats des opérations.

Nous allons de plus avoir besoin d'une autre pile pour l'historique.

Le C++ actuel, propose dans sa STL (Standard Template Library) une classe stack. Cependant, celle-ci ne se comporte pas tout à fait comme une pile classique, à savoir que l'opération pop() dépile bien le résultat mais ne le retourne pas. Il faut pour cela d'abord utiliser top() qui elle retourne le résultat mais ... ne le dépile pas.

Je vous propose donc une classe patron vStack^↓, extrêmement basique, basée sur des vecteurs, qui se comporte comme espéré.

Transformation d'une chaîne de caractères en nombre réel

Les expressions que va entrer l'utilisateur vont toujours être "vues" par notre programme comme des chaînes de caractères. Cependant ce sont des nombres que nous désirons manipuler. Il faut donc faire la conversion d'une représentation à l'autre.

Pour faire cela il existe plusieurs moyens :

• faire la conversion à la main en analysant la chaîne de caractères ;
• utiliser les bibliothèques C et la fonction strtod ;
• utiliser les conversions faites par les flux de la bibliothèque iostream du C++.

C'est cette dernière solution que nous allons utiliser.

Pour cela vous déclérerez une variable de type istringstream dont l'instance sera initialisée à la construction avec la chaîne de caractères à convertir.

Cette chaîne de caractères sera du type string qui est une des classe de base de la STL et qui, comme son nom l'indique, permet de manipuler des chaînes de caractères : de plus elle a l'avantage de proposer une gestion telle que le programmeur n'a pas à se soucier de la gestion de l'espace nécessaire à leur stockage.

Cette classe propose une interface qui permet de manipuler les objets de type string comme des flux d'entrée.

Cela signifie que l'on va pouvoir extraire notre chaîne de caractères dans un objet d'un autre type avec l'opérateur >> et que la conversion va se faire automatiquement.

Cependant, il se peut que cette conversion échoue (par exemple, on ne parviendra pas à convertir la chaîne "cent vingt cinq virgule 12" en un double). Dans ce cas, l'opérateur >> va positionner des bits d'erreur dans l'objet sur lequel il est utilisé, ici notre istringstream. La lexture de ces bits se fait à l'aide de la méthode rdstate de l'objet en question dont on combine la valeur retournée aux valeurs ios::failbit, ios::badbit, ... comme dans le code ci-dessous :

double toDouble(const string &s, bool &err)
{
	istringstream S(s) ;
	double d ;

	S >> d ;

	if ( S.rdstate() & ios::failbit ) {
		// ça n'a pas fonctionné
	} else {
		// ça a fonctionné
	}

	// ...

	return d ;
}

Enfin, pour utiliser istringstream vous devrez inclure les fichiers d'en-têtes iostream et sstream.

Découpage et gestion des expressions

Les expressions sont ce qui va nourrir notre calculette. Nous avons vu de quoi elles doivent être composées mais rien ne permet de savoir ce que l'utilisateur va entrer et dans quel ordre. Pour cela il faut que notre programme tourne autour d'une boucle de prise en charge d'une expression.

Dans un premier temps, nous considérerons que l'expression est une unique chaîne de caractères comme dans l'exemple ci-dessous :

#> ./pcalc
Bienvenue dans Pcalc v0.1beta
Bons calculs...

pcalc> 4 3 +
7
pcalc> 

Cette expression sera stockée dans une variable de type string pour ensuite être découpée et analysée conformément à l'algorithme.

Comme vous disposez déjà d'une classe de pile, vous pouvez traiter directement les opérandes. Nous verrons les opérateurs plus tard.

Mode non-interactif

Dans ce mode, l'espression à évaluer est passée directement sur la ligne de commande. Plusieurs cas peuvent alors se présenter et nous en montrons certains sur l'exemple ci-dessous :

#> ./pcalc 4 3 +
7
#> ./pcalc "4 3 +"	← Notez les guillemets
7
#> ./pcalc "4 3" +	← Notez le mélange guillemets/non-guillemets
7
#>

Mode interactif

Que ce soit en mode interactif ou pas, notre programme va traiter les expressions qui lui sont passées.

En mode interactif, il va devoir en plus traiter les commandes passées par l'utilisateur.

Le mode interactif est utilisé automatiquement lorsque le programme est lancé sans argument.

Gestion d'un arbre binaire

Pour que notre programme puisse faire la conversion d'une notation à l'autre, nous devons transformer notre historique en un arbre binaire d'évaluation.

Pour cela, nous avons besoin d'une classe représentant un arbre binaire. Comme il n'en existe pas dans la STL et que nous sommes ici dans un but d'apprentissage^↓, nous allons la créer.

Cette classe devra être générique : ce sera une classe patron (template) qui pourra contenir n'importe quel type d'objet (un arbre de nombres réels, un arbre de personnes, ...). Ceci permet donc que la réutiliser dans d'autres situations, dans d'autres programmes et c'est là tout l'avantage de la programmation objet.

Pour vous aider dans l'écriture de cette classe, vous trouverez dans la figure ci-dessous la déclaration de la classe, de ses champs et de ses méthodes.

#ifndef _NODE_H_
#define _NODE_H_

template <typename T>
class node {
public:
	// Deux constructeurs pour cette classe
	node (T value) ;
	node (T value, node *left, node *right) ;
	
	// L'objet stocké.
	// Il est public, donc il n'y aura pas besoin de
	// méthode particulière pour y accéder, en lecture
	// et/ou en écriture.
	T value ;

	// Méthode qui retourne une copie du noeud courrant
	// Elle est déclarée 'const' car elle ne modifie pas
	// l'objet qu'elle manipule
	node *copy() const ;

	// Une méthode permettant de détruire un noeud
	void release() ;

	// Méthodes de positionnement et d'accès aux fils.
	// Pour simplifier l'écriture, nous utilisons la
	// surcharge de méthodes : pour chaque fils, nous avons
	// deux méthodes avec le même nom mais qui
	// i ) n'admettent pas les mêmes arguments et
	// ii) ne retournent pas le même type.
	node *left() const ;
	void left(node<T> *l) ;
	node *right() const ;
	void right(node<T> *r) ;

protected:
	// Les pointeurs vers les fils d'un noeud ne
	// sont pas publics, mais protégés.
	// Si une classe hérite de celle-ci, elle pourra
	// manipuler directement ces champs sans passer
	// par les méthodes left(...) et right(...)
	// ci-dessus.
	node<T> *leftptr ;
	node<T> *rightptr ;
} ;

#endif

Éléments de stockage

Mais que va donc contenir notre arbre ? D'un côté nous avons les opérateurs et de l'autre les opérandes. Bien que notre classe d'arbre binaire soit générique, elle n'est capable de stocker qu'un type d'objet à la fois.

Pour palier ce problème une solution est de créer une classe container qui puisse recevoir nos deux objets. Encore une fois, il y a plusieurs façons de faire. À vous de choisir parmi l'une de celles-là, ou même une autre :

• créer une classe container virtuelle puis deux autres classes héritant de celle-là, l'une représentant un opérateur, l'autre une opérande ;
• créer une classe "double effet" qui contienne une structure spéciale permettant de savoir si le contenu est à considérer comme un opérateur ou plutôt comme une opérande ;
• ...