Une calculatrice traitant les caractères....

Commenter

Contenu du snippet

C'est une calculatrice que j'ai récuperer de chez wrox, un livre nommé visual c++, de monsieur Horton Ivor, et je m'en suis servit pour traiter des opération mathématique simple. La fonction traite les parenthèses, ça aide ^^.
Je n'ai pas touché au char... je ne les ai pas traduit en TCHAR, mais elle fonctionne quand meme. ;)

Source / Exemple : 


// maDLL.cpp : définit les fonctions exportées pour l'application DLL.
//

#include "stdafx.h"

// Programme créant une calculatrice
//#include <iostream>						// Pour le flot entré sortie
#include <cstdlib>						// Pour la fonction exit()
#include <cctype>						// Pour la fonction isdigit()
using namespace std;

const int MAX = 255;

void eatspace(char * str);
double expr(char* str);					// fonction évaluant une expression arithmétique
double term(char* str, int& index);		// Fonction extrayant la valeur d'un terme
double number(char* str, int& index);	// fonction reconnaissant un nombre dans une chaine
char* extract(char* str, int& index);	// Fonction extrayant une sous-chaine entre parenthèse

extern "C" __declspec(dllexport) double __stdcall calcul(char* buffer)
{
//	char* buffer = {0};		//Zone de stockage de l'expression
	//strcpy_s(buffer,sizeof(texte),texte);
	for(;;)
	{
		eatspace(buffer);
		if(!buffer[0])
			return 0;
		return expr(buffer);
	}
}

char* extract(char* str, int& index)
{
	char buffer[MAX];							//	 Espace temporaire pour une sous chaine
	char* pstr = 0;								//	Pointeur désignant la nouvelle chaine à retourner
	int numL = 0;								//	Nombre de parenthèse gauche
	int bufindex = index;						// Enregistre la valeur de début de l'index
	do
	{
		buffer[index - bufindex] = *(str + index);
		switch(buffer[index - bufindex])
		{
			case ')':
				if(numL == 0)
				{
					buffer[index - bufindex] = '\0'; // Remplacd ')' par '\0'
					++index;
					pstr = new char[index - bufindex];
					if(!pstr)
					{
						//cout << "Erreur d'allocation de mémoire,"
						//	 << " programme terminé.";
						exit(1);
					}
					strcpy_s(pstr,sizeof(buffer), buffer);		// Copy la sous chaine dans la nouvelle mémoire..
					return pstr;
				}		
				else
					numL--;	
				break;
			
			case '(': numL ++;break;			// Augmente le nombre de ( à égaliser
		}
	} while(*(str + index++) != '\0');			// Boucle - ne pas dépasser la fin de la chaine

	exit(1);
	return pstr;
}

void eatspace(char * str)
{//	cout << "\nentrée de eatspace\n";

	int j = 0;		// index source de la chaine
	int i = 0;		// index cible de la chaine
	

	while((*(str + i) = *(str + j++)) != '\0')
		
		if(*(str + i) != ' ')
			i++;
//	cout << "\nsorti de eatspace\n";

	return;
}
	

//fonction reconnaissant un nombre dans une chaine
// ou une expression entre parenthèse
double number(char* str, int& index)
{
	double value = 0.0;									// Stock la valeur résultante
	//cout << "\nentrée de number\n";
	if(*(str + index) == '(')							// Début des parenthèse
	{
		char* psubstr = 0;					// Pointeur de sous chaine
		psubstr = extract(str, ++index);	// Extrait la sous-chaine entre parenthèse
		value = expr(psubstr);				// Extrait la valeur de la sous chaine
		delete[] psubstr;					// Nettoie le tas
		return value;
	}
	// Récupération de la partie entière du nombre
	while(isdigit(*(str + index)))	// 
		value = 10 * value + (*(str + index++) - 48);

	if((*(str + index) != '.')&&(*(str + index) != ','))
		return value;

	double factor = 1.0;
	
	// Récupération de la partie décimal du nombre
	while(isdigit(*(str + (++index))))
	{
		factor *= 0.1;
		value = value + (*(str +index) - 48)*factor;
	}
	
	return value;

}

// Fonction extrayant la valeur d'un terme
double term(char* str, int& index)
{	//cout << "\nentré dans term\n";
	double value = 0.0;			// Cumul du résultat

	value = number(str, index);		//Extrai du 1er nombre du term

	// Itération tant que l'opérateur n'est pas aproprié
	while((*(str + index) == '*') || (*(str + index) == '/'))
	{
		if(*(str + index) == '*')
			value *= number(str, ++index);
		
		if(*(str + index) == '/')
			value /= number(str, ++index);
	}
	//cout << "\nsortie dans term\n";
	return value;
}

//fonction évaluant une expression arithmétique
double expr(char* str)
{	//cout << "\nentré dans expr\n";
	double value = 0.0;				// Stocke le résultat ici
	int index = 0;					// Suit l'emplacement du caractère courant
	value = term(str, index);		// Extrait le premier terme

	for(;;)	// boucle infini
	{
		switch(*(str + index++)) // choisie l'opération à partir du caractère courant
		{
			case '\0': return value;
			case '+' : value += term(str, index); break;//
			case '-' : value -= term(str, index); break;//
			default : 
				exit(1);
		}
	}
//	cout << "\nsorti de expression\n";		
}

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 (jbs106)