Évaluateur d'expressions booléennes (bee)

Télécharger le projet
Commenter

Description

BEE(Boolean Expression Evaluator) permet d'évaluer des expressions booléennes.

Les opérateurs et symboles prédéfinis sont :
0 : faux
1 : vrai
& : opérateur et
| : opérateur ou
! : opérateur non
( : parenthèse gauche
) : parenthèse droite
Il est cependant possible de spécifier ses propres valeurs.

Des variables peuvent de plus être utilisées dans les expressions.

Les erreurs (de syntaxe, de parenthésage, de variable indéfinie) sont gérées et peuvent être récupérées en utilisant un bloc try catch autour de l'appel de la méthode eval (voir l'exemple "simple").
Il est possible de connaître la description de l'erreur et la position du caractère fautif dans l'expression normalisée.

Le code est commenté et documenté (la documentation est déjà générée et le fichier Doxyfile est fourni).

Deux exemples sont fournis avec le code :
- simple : permet d'évaluer des expressions booléenne avec variables et possibilité de choisir ses opérateurs.
- table : permet de générer la table de vérité d'une expression booléenne. (c'est celui qui est affiché ci-dessous)

Attention, le zip et le code fournis sur cette page ne sont pas forcément à jour ! Pour voir les dernières sources, rendez-vous ici : https://bitbucket.org/mcc/dev/src/tip/BEE/

Source / Exemple : 


#include "../../src/BEE.hpp"
#include <iomanip>
#include <cmath>

int main(int argc, char** argv) {
	
	if(argc == 1) {
		std::cerr << "Usage : " << argv[0] << " expression booleenne"
				  << std::endl;
		return 1;
	}
	
	try {
		BEE bee(argv[1]);
		std::vector<std::string> vars = bee.vars();
		
		//Affichage de l'entête.
		for(unsigned int i = 0; i < vars.size(); i++) {
			std::cout << vars[i] << " ";
		}
		std::cout << argv[1] << std::endl;
		
		//On doit trouver toutes les valeurs possibles pour toutes les
		//variables. Ca revient à convertir en binaire les nombres de 0 à 
		//2 ^ nbVars. On prend ensuite chaque bit de ces nombres et on assigne
		//chacun d'eux à la variable associée.
		int nbVars = vars.size();
		int sizeType = 4 * sizeof(int);
		int nbLines = pow(2, nbVars);
		int maxType = pow(2, sizeType - 1);
			
		for(int l = 0; l < nbLines; l++) {
			//On se décale jusqu'aux bits utiles.
			int t = l << (sizeType - nbVars);
			
			//On affiche les bits.
			for(int i = 0; i < nbVars; i++) {
				bool valBit = t & maxType;
				bee.setVar(vars[i], valBit);
				t <<= 1;
				std::cout << valBit << std::setw(vars[i].length() + 1);
			}
			
			//On évalue l'expression avec les nouvelles valeurs.
			bool res = bee.eval();
			std::cout << res << std::endl;
		}
	} catch(BEE::Error err) {
		std::cout << std::endl;
		std::cout << err.src() << std::endl;
		std::cout << std::setw(err.ind() + 1) << "^" << std::endl;
		std::cout << std::setw(err.ind() + err.desc().length()) << err.desc()
				  << std::endl;
	}
	
	return 0;
}

Conclusion :


Cette source peut être utile notamment pour savoir comment convertir une expression (booléenne ou non) en notation polonaise inversée. (l'algorithme n'est pas entièrement de moi, sa structure provient d'une page Wikipédia mentionnée au dessus de la fonction concernée).

Il existe peut-être des bugs, si c'est le cas, merci de me les indiquer.
Télécharger le projet

Codes Sources

A voir également

S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.

Du même auteur (macsou01)