Je ne souhaiterai pas passer par les arbres parce que je pense que ce n'est pas trop adapté sur ti68k. Je souhaiterai un algo itératif, parce que la recursivité n'est pas adaptée au 68k.
j'ai commencé à develloper un petit peu sous vc++ pour voir si l'algo que j'ai choisi est adapté, je ne sais meme pas si il marche dans tous les cas... mais bon le peu de cas que j'ai essayés marchent.
condition: l'expression doit etre valide (chiffre à virgule, + - / * (operateur binaire exclusivement pour le moment..)
A noter que seul l'algo est important.; c mal codé, et en plus les opérations devraient se faire sur des nombres de taille infini.. donc pas de double. n>>Exp; cout<<endl<<"Analyse de l'expression: "<<Exp<<endl; eval(Exp); return 0; }
qu'en pensez vous? Pensez vous qu'il puisse etre adapté à une expression avec parenthèses et fonctions?// az.cpp : Defines the entry point for the console application.
//
#include "stdafx.h"
#include <iostream>
using namespace std;
/**********************************************************/
char Op[500];
double Nbr[500];
int iOp = 0;
int iNbr = 0;
#define EmpilerOp(pExp) Op[iOp++]=(pExp)
#define EmpilerNbr(dNbr) Nbr[iNbr++]=dNbr
#define DepilerNbr() (Nbr[--iNbr])
#define DepilerOp() (Op[--iOp])
/**********************************************************/
int PrioriteOp(char Op)
{
switch(Op)
{
case '+': // binaire ...
case '-':
return 12;
case '*':
case '/':
default:
return 13;
}
}
double calcul(double dNbr1, char Op, double dNbr2)
{
switch(Op)
{
case '+':
return dNbr1+dNbr2;
case '-':
return dNbr1-dNbr2;
case '/':
return dNbr1/dNbr2;
case '*':
default:
return dNbr1*dNbr2;
}
}
void eval(char *pExp)
{
double dNbr,dDec;
char Op1,Op2;
while (*pExp)
if ( *pExp == '+' || *pExp == '-' || *pExp == '/' || *pExp == '*' )
EmpilerOp(*pExp++);
else
{
dNbr = 0;
while ((*pExp>='0' && *pExp <='9'))
dNbr = dNbr*10 + *pExp++ - '0';
if (*pExp=='.' || *pExp ==',')
{
pExp++;
dDec = 10;
while ((*pExp>='0' && *pExp <='9'))
{
dNbr = dNbr + (*pExp++ - '0')/dDec;
dDec*=10;
}
}
if (iOp>=2)
{
Op1 = DepilerOp();
Op2 = DepilerOp();
EmpilerOp(Op2);
if ( PrioriteOp(Op1) > PrioriteOp(Op2) ) // on effectue le calcul du haut de la pile
{
dNbr = calcul(DepilerNbr(),Op1,dNbr);
}
else
{
EmpilerOp(Op1);
}
}
EmpilerNbr(dNbr);
}
for (int i=1;i<iNbr;i++)
Nbr[i] = calcul(Nbr[i-1], Op[i-1],Nbr[i]);
cout << "Resultat : " << Nbr[iNbr-1]<<endl;
}
int main(int argc, char* argv[])
{
char Exp[500];
ci
!), mais voici ce que je ferais en itératif pour la gestion des parenthèses :
