Sujet Précédent Sujet Suivant

Compilateur

mousekey -  
mamiemando Messages postés 33869 Date d'inscription   Statut Modérateur Dernière intervention   -
Bonjour,
je dois faire un compliteur qui gère les équations avec + - / * et ^(puissance)...

J'utilise les tableaux pour mon équations en postfixée...

pour la transformation en postfixée ca marche bien... sauf que quand je dois afficher mes informations, j'ai un problème pour éliminer mes symboles déjà traités...

voici l'énoncé du problème...

http://w3.uqo.ca/jurek/inf4393/d3.pdf

Pouvez vous m'aider???:$:$:$:$

voici mon code sources....

/////////////////////////////////////////////////////////
//But: mettre une équation en post fixée.
//Auteur : Eric Soulard
//Date de création : 14 novembre 2005
//dernière modification :
/////////////////////////////////////

#include <iostream>
#include <cstdlib>
#include <fstream>
#include <string>
#include <ctype.h>

using namespace std;

struct LISTE{
char element;
LISTE *suivant;
};
void AfficherListe(char element[255], int nbElement);
// void SupprimerUnNoeud(char liste[255], int numero_noeud);
char ObtenirUnNoeud(char liste[255], int i );
int LireFichier(char element[255]);
bool EstVide(char liste[255]);
char ObtenirPremierElement(char liste[255]);
void MettreEnPostFixe(char liste[255], char listeOperante[255], int &nbElementPile,
int &nbElementListeOperante, int nbCarLu);
int PrioriteOperateur(char op);
void AfficherResultat(char liste[255]);
void InsererListe(char liste[255], char valeur);
//void Supprimer(char liste[255]);
int LireFichier(void);
void PlacerOperateur(char listeOperante[255], char pile[255], char liste, int &nbElementPile,
int &nbElementListeOperante, char valeur);
int PrioriteOperateur(char op);

//////////////////////////////////////////////////
//But : insérer un nouveau noeud à la fin de la liste.
//paramètre entré : tete la liste des noeuds
// valeur : la valeur à insérer dans la liste
////////////////////////////////////////////

void InsererListe(char liste[255], char valeur){

// LISTE *liste = tete, *nouveau = new LISTE;
//nouveau->element=valeur;
//nouveau->suivant=NULL;

/*for( ; liste->suivant != NULL; liste= liste->suivant);

if ( liste->suivant == NULL)
liste = nouveau;
else{
cerr << "Erreur lors de l'ajout";
exit(1);
}
*/
}

//////////////////////////////////////////////////
//But : supprimer un noeud en particulier dans la liste
//paramètre entré : tete la liste des noeuds
// numero_noeau : le numéro du noeud à enlever
////////////////////////////////////////////

//////////////////////////////////////////////////
//But : lire le fichier
//paramètre entré : tete la liste des noeuds
////////////////////////////////////////////

int LireFichier(char element[255]){
ifstream fichier;
//char element;
// LISTE* liste = tete;

fichier.open("donnee.txt", ios::in);
int compteur = 0;
if ( !fichier){
cerr << "Erreur lors de l'ouverture du fichier donnee.txt";
exit(1);
}

//lire le nombre
// si le caractère lu est un nombre
//ajouter le nombre dans le tableau
//sinon afficher le message d'erreur à l'écran
fichier.getline(element,255,'\n');

element[strlen(element)+1]= '\0';

return strlen(element);

}
//////////////////////////////////////////////////
//But : vérifier si la liste est vide ou pas
//paramètre entré : tete la liste des noeuds
//retour : true si la liste est vide
// false si la liste est non vide
////////////////////////////////////////////

bool EstVide(char liste[255]){

return ( liste[0] == 0 );
}

//////////////////////////////////////////////////
//But : obtenir le dernier élément de la liste
//paramètre entré : tete la liste des noeuds
//retour : le caractère du dernier noeud de la liste
////////////////////////////////////////////

char ObtenirDernierElement(char liste[255], int taille){

/* if ( tete == NULL ) return '-';
LISTE *liste = tete, *temp;
char elementListe;

for ( liste ; liste->suivant != NULL ; liste = liste->suivant);

if ( liste->suivant != NULL){
temp = liste->suivant;
liste = liste->suivant;
temp->suivant=NULL;
delete temp;
}else{
delete liste;
}*/

return liste[taille];
}

//////////////////////////////////////////////////
//But : obtenir le premier élément de la liste
//paramètre entré : tete la liste des noeuds
//retour : le caractère du premier noeud de la liste
////////////////////////////////////////////

char ObtenirPremierElement(char liste[255]){

/*LISTE *liste = tete, *temp;
char elementListe;

if ( liste->suivant != NULL){
if ( liste->suivant != NULL){
temp = liste->suivant;
liste->suivant = liste->suivant->suivant;
temp->suivant=NULL;
elementListe = temp->element;
}else{
temp = liste->suivant;
elementListe = temp->element;
temp->suivant=NULL;
}
delete temp;
}
*/

return liste[0];
}

//////////////////////////////////////////////////
//But : mettre l'équation en post fixée
//paramètre entré : tete la liste des noeuds
// pile la pile d'opérateur( +-/*^)
// listeOperante la liste des variables
////////////////////////////////////////////

void MettreEnPostFixe( char pile[255], char listeOperante[255], char tete[255], int &nbElementPile,
int &nbElementListeOperante, int NbValeurLu){

// LISTE* liste = tete;

int compteur = 0, nbLettre = 0,nbOperateur=0;
while(NbValeurLu > compteur){
if ( isalpha(tete[compteur]) == 1 && tete[compteur] != '='){
listeOperante[nbElementListeOperante++] = tete[compteur];
nbLettre++;
//InsererListe(listeOperante, tete[0]);
}else{

PlacerOperateur(listeOperante, pile, tete[compteur], nbElementPile, nbElementListeOperante, NbValeurLu);
nbOperateur++;
nbLettre=nbElementListeOperante;
// (nbElementPile)++;
}
compteur++;
//liste=liste->suivant;
}

/* if ( nbLettre != nbOperateur +1){
cerr << "Le nombre d'élément est invalide..."<<endl;
exit(1);
}
*/ if ( compteur > 5 ) compteur--;
else compteur--;
while(pile[0] != 0){
listeOperante[nbLettre++] = pile[nbElementPile-1];
pile[nbElementPile-1]=0;
nbElementPile--;
// compteur++;
nbElementListeOperante++;

//InsererListe(listeOperante, ObtenirPremierElement(pile));
}
}
//////////////////////////////////////////////////
//But : vérifie si j'ai bien un bon opérateur
//paramètre entré : opérateur à tester
//retour : true si l'élément est bien un opérateur
// false si l'élément n'est pas un opérateur
////////////////////////////////////////////

bool IsValideOperator(char element){

if (element != '+' || element != '-' || element != '/' || element != '*' || element != '^' || element != ';')
return true ;
return false;
}

//////////////////////////////////////////////////
//But : obtenir un élément de la liste
//paramètre entré : tete la liste des noeuds
// i le numéro du noeud
//retour : le caractère du noeud i de la liste
////////////////////////////////////////////

char ObtenirUnNoeud(char liste[255], int i ){

/* LISTE* liste = tete;
int compteur=1;
for( ; liste->suivant != NULL; liste = liste->suivant){

if ( compteur++ == i) return liste->element ;
}
return '-1';*/

return liste[i];
}

//////////////////////////////////////////////////
//But : afficher les informations en langage machine
//paramètre entré : tete la liste des noeuds
////////////////////////////////////////////

void Affichage(char liste[255],int nbElement){

// LISTE *liste = tete ;
bool Variable[10];
char arg1, arg2;
int numero_noeud = -1;
bool op ;
int i ,posArg1;
int compteur = 0 ;
int EmplacementRD, EmplacementRA;
for ( i = 0 ; i <10;++i){
Variable[i]=false;
}
//liste = tete;
// InsererListe(liste, '-1');
while(nbElement >= 1){
EmplacementRD =100;
EmplacementRA = 100;
++numero_noeud;
op=false;
/* while ( IsValideOperator(liste->element) == false){
arg1=liste->element ;
liste=liste->suivant ;
arg2 = liste->element ;
liste=liste->suivant ;
}*/
if ( IsValideOperator(liste[numero_noeud]) == true ){
switch(liste[numero_noeud]){
case 43/*'+'*/:
cout << "ADD " ;
op=true;

for ( i = 0 ; i <=9 ; i++) {
if ( Variable[i] == true ) break;
}
if ( i == 10 ) Variable[0] = true;
else Variable[i+1] = true;
if ( numero_noeud == 3 )
arg1= liste[1];
if ( i == 10 && Variable[i-1] == false ){
if( (arg1 = liste[numero_noeud-2]) == -1){
cerr <<"Erreur lors de l'obtention de la variable.";
exit(1);
}
}else EmplacementRD=i;
posArg1 = numero_noeud-2;
for ( i = 1 ; i <=9 ; i++) {
if ( Variable[i] == true ) break;
}
if ( i == 10 && Variable[i-1] == false ){
if ( (arg2 = liste[numero_noeud-1]) == -1){
cerr <<"Erreur lors de l'obtention de la variable.";
exit(1);
}
if ( i == 10 ) cout <<"R0";
else cout <<"R"<<i;
cout << " , "<<arg1 <<" "<<arg2<<endl;
posArg1 = numero_noeud-2;
if ( i == 10 ) Variable[0] = true ;
else Variable[i+1] = true ;
break;
}else{
EmplacementRA = i;
//Variable[EmplacementRA] = false;
}
EmplacementRA = i;
if ( EmplacementRD < 10 && EmplacementRA < 10 ){
cout << "R"<<EmplacementRD<<", R"<<EmplacementRD << " R"<<EmplacementRA<<endl;
Variable[i] = true ;
if ( liste[EmplacementRA] == '='){
liste[1] = liste[2];
posArg1 =2;
}
else{
liste[numero_noeud] = liste[nbElement];
posArg1 = EmplacementRA;
}
nbElement--;
Variable[i] = true ;
break;
}
for( i =0 ; i <=9 ; ++i) {
if ( Variable[i] == false) break;

cout <<"R"<<i;
cout << " , "<<"R"<<i<<" "<<arg2<<endl;
posArg1 = numero_noeud;

}
posArg1 = numero_noeud-1;
Variable[i] = true;

for ( i = 0 ; i <=9 ; i++)
if ( Variable[i] == true ) break;
cout <<"R"<<i<<",";
cout <<"R"<<i;
cout << " , "<<arg1 <<endl;
Variable[i] = true ;
break;
case 45/*-'*/:
cout << "SOU " ;
op=true;
for ( i = 0 ; i <=9 ; i++) {
if ( Variable[i] == true ) break;
}
if ( i == 10 && Variable[i-1] == false ){
if ( (arg1 = liste[numero_noeud-2]) == -1){
cerr <<"Erreur lors de l'obtention de la variable.";
exit(1);
}
}else EmplacementRD=i;
posArg1 =numero_noeud-2 ;
for ( i = 1 ; i <=9 ; i++) {
if ( Variable[i] == true ) break;
}
if ( i == 10 && Variable[i-1] == false ){
if ( (arg2 = liste[numero_noeud-1]) == -1){
cerr <<"Erreur lors de l'obtention de la variable.";
exit(1);
}

if ( EmplacementRD != 100){
if ( i == 10 ) cout << "R0";
else cout <<"R"<<i;
cout << " , R"<<EmplacementRD<<" "<<arg2<<endl;
posArg1 = numero_noeud-1;

}else{
cout <<"R"<<i;
cout << " , "<<arg1 <<" "<<arg2<<endl;
}
break;
}else{
EmplacementRA = i;
//Variable[EmplacementRA] = false;
}
if ( EmplacementRD < 10 && EmplacementRA < 10 ){
cout << "R"<<EmplacementRD<<", R"<<EmplacementRD << " R"<<EmplacementRA<<endl;
liste[numero_noeud] = liste[nbElement];
nbElement--;
break;
}
for( i =0 ; i <=9 ; ++i)
if ( Variable[i] == false) break;
Variable[i] = true;
cout <<"R"<<i;
cout << " , "<<arg1 <<" "<<arg2<<endl;
posArg1 = numero_noeud-2;

break;
case 42/*'*'*/:
cout << "MUL " ;
op=true;
for ( i = 0 ; i <=9; i++) {
if ( Variable[i] == true ) break;
}
if ( i == 10 && Variable[i-1] == false ){
if ( (arg1 = liste[numero_noeud-2]) == -1){
cerr <<"Erreur lors de l'obtention de la variable.";
exit(1);
}
}else{
if (liste[numero_noeud+1]== '+' || liste[numero_noeud+1] =='-'
|| liste[numero_noeud+1] == '*' || liste[numero_noeud+1] == '/'
|| liste[numero_noeud+1] == '^'){
if ( (arg1 = liste[numero_noeud-2]) == -1){
cerr <<"Erreur lors de l'obtention de la variable.";
exit(1);
}
}
else
EmplacementRD=i;
}

posArg1 = numero_noeud-2;
for ( i = 1 ; i <=9 ; i++) {
if ( Variable[i] == true ) break;
}
if ( i == 10 && Variable[i-1] == false ){
if ( (arg2 = liste[numero_noeud-1]) == -1){
cerr <<"Erreur lors de l'obtention de la variable.";
exit(1);
}
}else{
if ( i == 10 && Variable[i-1] == false ){
if ( (arg2 = liste[numero_noeud-1]) == -1){
cerr <<"Erreur lors de l'obtention de la variable.";
exit(1);
}

}else{
EmplacementRA = i;
//Variable[EmplacementRA] = false;
}
}
if ( EmplacementRD < 10 && EmplacementRA < 10 ){
cout << "R"<<EmplacementRD<<", R"<<EmplacementRD << " R"<<EmplacementRA<<endl;
liste[numero_noeud] = liste[nbElement];
nbElement--;
break;
}
for( i =0 ; i <=9 ; ++i)
if ( Variable[i] == false) break;
if ( i == 10 ) cout <<"R0";
else cout <<"R"<<i;
cout << " , "<<arg1 <<" "<<arg2<<endl;
posArg1 = numero_noeud-2;
for( i = 0 ; i < 10 ; i++)
if ( Variable[i] == false ) break;
Variable[i] = true ;
//}
break;
case 47 /*'/'*/:
cout << "DIV " ;
op=true;
for ( i = 0 ; i <=9 ; i++) {
if ( Variable[i] == true ) break;
}
if ( i == 10 ) Variable[0] = true;
else{
if ( i + 1 <= 10)
Variable[i+1] = true;
}
EmplacementRD=i;
if ( i == 10 && Variable[i-1] == false ){
if ( (arg1 = liste[numero_noeud-2]) == -1){
cerr <<"Erreur lors de l'obtention de la variable.";
exit(1);
}
}else{
if (liste[numero_noeud+1]== '+' || liste[numero_noeud+1] =='-'
|| liste[numero_noeud+1] == '*' || liste[numero_noeud+1] == '/'
|| liste[numero_noeud+1] == '^'){
if ( (arg1 = liste[numero_noeud-2]) == -1){
cerr <<"Erreur lors de l'obtention de la variable.";
exit(1);
}
EmplacementRD=i;
}
else
EmplacementRD=i;
}

for ( i = 1 ; i <=9 ; i++) {
if ( Variable[i] == true ) break;
}
if ( i == 10 && Variable[i-1] == false ){
if ( (arg2 = liste[numero_noeud-1]) == -1){
cerr <<"Erreur lors de l'obtention de la variable.";
exit(1);
}
if ( EmplacementRD == 10) cout <<"R0";
else cout <<"R"<<i;
cout << " , "<<arg1 <<" "<<arg2<<endl;
posArg1 = numero_noeud-2;
break;
}else{
EmplacementRA = i;
//Variable[EmplacementRA] = false;
if ( EmplacementRD == 10) cout <<"R0";
else cout <<"R"<<i;
cout <<", R" << EmplacementRD <<" R"<<EmplacementRA<<endl;
posArg1 = numero_noeud-2;
if (EmplacementRA!=100) Variable[EmplacementRA] = false;
posArg1 = EmplacementRA;
break;
}
if ( i == 10 ) Variable[0] = true;
else{
if ( i + 1 <= 10)
Variable[i+1] = true;
}

cout <<"R"<<i;
cout << " , "<<arg1 <<" "<<arg2<<endl;
posArg1 = numero_noeud-2;
Variable[i] = true;
break;
case 94/*'^'-*/:
cout << "EXP " ;
op=true;
for ( i = 0 ; i <=9 ; i++) {
if ( Variable[i] == true ){
break;
}
}
if ( i == 10 ) Variable[0] = true;
else{
if ( i + 1 <= 10)
Variable[i+1] = true;
else{
cerr << "Manque de registres."<<endl;
exit(1);
}
}

if ( i == 10 && Variable[i-1] == 0 || IsValideOperator(liste[numero_noeud+1])){
if ( (arg1 = liste[numero_noeud-2]) == -1){
cerr <<"Erreur lors de l'obtention de la variable.";
exit(1);
}
posArg1 = numero_noeud-2;
if ( i == 10 ) Variable[0] = true;
else{
if ( i + 1 <= 10)
Variable[i+1] = true;
}
EmplacementRD=i;
}else EmplacementRD=i;

for ( i = 1 ; i <=9 ; i++) {
if ( Variable[i] == true ) break;
}
if ( i == 10 && Variable[i-1] == false || IsValideOperator(liste[numero_noeud+1])){
if ( (arg2 = liste[numero_noeud-1]) == -1){
cerr <<"Erreur lors de l'obtention de la variable.";
exit(1);
}
if ( EmplacementRD == 10)
cout <<"R0";
else
cout <<"R"<< i;
cout << " , "<<arg1 <<" "<<arg2<<endl;
break;
}else{
EmplacementRA = i;
//Variable[EmplacementRA] = false;
}
if ( EmplacementRD < 10 && EmplacementRA < 10 ){
cout << "R"<<EmplacementRD<<", R"<<EmplacementRD << " R"<<EmplacementRA<<endl;
liste[numero_noeud] = liste[nbElement];
nbElement--;
break;
}
posArg1 = numero_noeud-2;
for( i =0 ; i <=9 ; ++i)
if ( Variable[i] == false) break;
Variable[i]=true;
if ( EmplacementRD <= 10) cout <<"R"<<i;
else cout <<"R0";
cout << " , "<<arg1 <<" "<<arg2<<endl;
posArg1 = numero_noeud-2;
Variable[0] = true ;
break;
case 61 /*'='*/:
cout << "AFF " ;
op=true;
if ( (arg1 = liste[numero_noeud-1]) == -1){
cerr <<"Erreur lors de l'obtention de la variable.";
exit(1);
}

for ( i = 0 ; i <=9 ; i++) {
if ( Variable[i] == true ) break;
}
if ( i == 10 && Variable[i] == false ){
if ( (arg2 = liste[numero_noeud-1]) == -1){
cerr <<"Erreur lors de l'obtention de la variable.";
exit(1);
}
cout <<"R"<<i;
cout << " , "<<arg1 <<" "<<arg2<<endl;
break;
}
cout <<arg1;
cout << " , "<<"R"<<i<<endl;

posArg1 = numero_noeud-1;

break;

};
if ( op == true){
if ( liste[2]!= '+' && liste[2] !='-' && liste[2] != '*' && liste[2] != '/' && liste[2] != '^'&& liste[2] != '=' ){
/*if ( liste[3]!= '+' && liste[3] !='-' && liste[3] != '*' && liste[3] != '/' && liste[3] != '^'&& liste[3] != '='
&& liste[3] != '1'){*/
liste[numero_noeud-2] = '-1';
liste[numero_noeud-1] = '-1';
liste[numero_noeud] = '-1';
/* }else{
liste[numero_noeud-1] = '-1';
if ( liste[numero_noeud+1] != '=')
liste[numero_noeud] = '-1';
}*/
}else{
if ( liste[2] != '=' )
liste[1]=liste[3];
else
liste[1]=liste[2];
posArg1++;
}
for (compteur = posArg1; compteur < nbElement ; compteur ++){
if ( compteur > 3|| posArg1 ==1)
liste[compteur]=liste[compteur+3];
/*else
if ( posArg1 == 1)
liste[compteur+1]=liste[compteur+3];*/
else
liste[compteur]=liste[compteur+1];

}
nbElement-=2;
numero_noeud=-1;
}

}
}

}
//////////////////////////////////////////////////
//But : placer dans la pile au bon endroit l'opérateur(+-...)
//paramètre entré : tete la liste des noeuds
// pile la pile d'opérateur
// valeur : la valeur à ajouter dans la pile
////////////////////////////////////////////

void PlacerOperateur(char listeOperante[255], char pile[255], char liste, int &nbElementPile,
int &nbElementListeOperante, char valeur){

/* LISTE *Lpile = pile;
LISTE *Loperante = listeOperante;
LISTE *nouveau = new LISTE;
nouveau->element=valeur;
nouveau->suivant=NULL;
*/
bool ajout = false;
if ( liste == '('){
pile[nbElementPile++] = liste;
//InsererListe(listeOperante, valeur);
}
if ( liste == ')'){
while(pile[nbElementPile] != '('){
pile[(nbElementPile)++] == liste;
;
//InsererListe(listeOperante, valeur);
// Supprimer(pile);
}

}
while ( !EstVide(pile) && ObtenirPremierElement(pile) != '(' &&
PrioriteOperateur(liste) < PrioriteOperateur( pile[nbElementPile-1] )){
listeOperante[nbElementListeOperante] = pile[nbElementPile-1];
pile[(nbElementPile)] = '-1';
nbElementListeOperante++;
nbElementPile--;
//InsererListe(listeOperante, pile[sizeof(pile)]);
// Supprimer(pile);
pile[(nbElementPile)++]=liste;
ajout = true;
// InsererListe(pile, valeur);
// Supprimer(pile);
}
if ( ajout == false) pile[(nbElementPile)++]=liste;
}

//////////////////////////////////////////////////
//But : affchier le contenu de la liste des noeuds à l'écran
//paramètre entré : tete la liste des noeuds
///////////////////////////////////////////

void AfficherListe(char element[255], int nbElement){

for( int compteur = 0 ;compteur <nbElement ; ++compteur){
cout << element[compteur]<<endl;
}

}
//////////////////////////////////////////////////
//But : supprimer le dernier noeud de la liste de noeud
//paramètre entré : tete la liste des noeuds
////////////////////////////////////////////
/*
void Supprimer(LISTE* tete){

LISTE *liste = tete;
LISTE *temp;

for(liste = liste->suivant ; liste->suivant->suivant != NULL ; liste = liste->suivant) ;

temp = liste->suivant->suivant;
liste->suivant = NULL;

delete temp;
}*/

//////////////////////////////////////////////////
//But : obtenir la priorité d'un opérateur
//paramètre entré : op l'opérateur à tester
//retour : entre 0 et 2 si l'opérateur est valide
// -1 dans le cas contraire
////////////////////////////////////////////

int PrioriteOperateur(char op){
if ( op != '+' && op != '-' && op != '/' && op != '*' && op != '^' && op != '=')
return -1;

/*
= priorité 0
+ - priorité 1
* / priorité 2
^ priorité 3
*/

switch ( op){
case 61/*'='*/:return 0;
break;
case 43/*'+'*/:
case 45 /*'-'*/: return 1;
break;
case 47/*'/'*/:
case 42/*'*'*/: return 2;
break;
case 94/*'^'*/: return 3;
break;
};

return -1 ;
}

//////////////////////////////////////////////////
//But : fonction principale
////////////////////////////////////////////

int main(){

char element[255];
char pile[255];
char listeOperante[255];
int nbElementPile = 0;
int nbElementListeOperante = 0;
int nbElementLu = 0;
for (int i = 0 ; i < 255;i++){
element[i]=0;
//listeOperante[i]=0;
//pile[i]=0;
}
/* listeOperante->element='-1';
listeOperante->suivant=NULL;
pile->element='-1';
pile->suivant=NULL;*/
nbElementLu = LireFichier(element);
cout << "Afficher la liste apres lecteure du fichier..."<<endl;
AfficherListe(element,nbElementLu);
MettreEnPostFixe(pile, listeOperante, element,nbElementPile, nbElementListeOperante,nbElementLu);
cout << "Afficher la pile"<<endl;
AfficherListe(pile,nbElementPile);
cout << "Afficher la liste des opérante..."<<endl;
AfficherListe(listeOperante,nbElementListeOperante);
Affichage(listeOperante, nbElementListeOperante);

return 0;
}

voici le contenu du fichier texte...

A=A*B-B^C

merci
mousekey

5 réponses

Réponse 1 / 5
mamiemando Messages postés 33869 Date d'inscription   Statut Modérateur Dernière intervention   7 902
 
Peux tu mettre ton code entre des balises code (selectionne le texte et clique sur code, juste au dessus de la boite de saisie) histoire qu'on y voit quelque chose. Je me penche sur ton cas ce soir.

En attendant essaye de vérifier si le problème vient de la manière dont tu stockes les données ou la manière dont tu les affiches. Pars sur un exemple simple (A+B) que tu enrichiras petit à petit.

Bonne chance
0
Réponse 2 / 5
mousekey
 
Salut,
voici mon code source...

<début>

/////////////////////////////////////////////////////////
//But: mettre une équation en post fixée.
//Auteur : Eric Soulard
//Date de création : 14 novembre 2005
//dernière modification :
/////////////////////////////////////

#include <iostream>
#include <cstdlib>
#include <fstream>
#include <string>
#include <ctype.h>

using namespace std;

struct LISTE{
char element;
LISTE *suivant;
};
void AfficherListe(char element[255], int nbElement);
// void SupprimerUnNoeud(char liste[255], int numero_noeud);
char ObtenirUnNoeud(char liste[255], int i );
int LireFichier(char element[255]);
bool EstVide(char liste[255]);
char ObtenirPremierElement(char liste[255]);
void MettreEnPostFixe(char liste[255], char listeOperante[255], int &nbElementPile,
int &nbElementListeOperante, int nbCarLu);
int PrioriteOperateur(char op);
void AfficherResultat(char liste[255]);
void InsererListe(char liste[255], char valeur);
//void Supprimer(char liste[255]);
int LireFichier(void);
void PlacerOperateur(char listeOperante[255], char pile[255], char liste, int &nbElementPile,
int &nbElementListeOperante, char valeur);
int PrioriteOperateur(char op);

//////////////////////////////////////////////////
//But : insérer un nouveau noeud à la fin de la liste.
//paramètre entré : tete la liste des noeuds
// valeur : la valeur à insérer dans la liste
////////////////////////////////////////////

void InsererListe(char liste[255], char valeur){

// LISTE *liste = tete, *nouveau = new LISTE;
//nouveau->element=valeur;
//nouveau->suivant=NULL;

/*for( ; liste->suivant != NULL; liste= liste->suivant);

if ( liste->suivant == NULL)
liste = nouveau;
else{
cerr << "Erreur lors de l'ajout";
exit(1);
}
*/
}

//////////////////////////////////////////////////
//But : supprimer un noeud en particulier dans la liste
//paramètre entré : tete la liste des noeuds
// numero_noeau : le numéro du noeud à enlever
////////////////////////////////////////////

//////////////////////////////////////////////////
//But : lire le fichier
//paramètre entré : tete la liste des noeuds
////////////////////////////////////////////

int LireFichier(char element[255]){
ifstream fichier;
//char element;
// LISTE* liste = tete;

fichier.open("donnee.txt", ios::in);
int compteur = 0;
if ( !fichier){
cerr << "Erreur lors de l'ouverture du fichier donnee.txt";
exit(1);
}

//lire le nombre
// si le caractère lu est un nombre
//ajouter le nombre dans le tableau
//sinon afficher le message d'erreur à l'écran
fichier.getline(element,255,'\n');

element[strlen(element)+1]= '\0';

return strlen(element);

}
//////////////////////////////////////////////////
//But : vérifier si la liste est vide ou pas
//paramètre entré : tete la liste des noeuds
//retour : true si la liste est vide
// false si la liste est non vide
////////////////////////////////////////////

bool EstVide(char liste[255]){

return ( liste[0] == 0 );
}

//////////////////////////////////////////////////
//But : obtenir le dernier élément de la liste
//paramètre entré : tete la liste des noeuds
//retour : le caractère du dernier noeud de la liste
////////////////////////////////////////////

char ObtenirDernierElement(char liste[255], int taille){

/* if ( tete == NULL ) return '-';
LISTE *liste = tete, *temp;
char elementListe;

for ( liste ; liste->suivant != NULL ; liste = liste->suivant);

if ( liste->suivant != NULL){
temp = liste->suivant;
liste = liste->suivant;
temp->suivant=NULL;
delete temp;
}else{
delete liste;
}*/

return liste[taille];
}

//////////////////////////////////////////////////
//But : obtenir le premier élément de la liste
//paramètre entré : tete la liste des noeuds
//retour : le caractère du premier noeud de la liste
////////////////////////////////////////////

char ObtenirPremierElement(char liste[255]){

/*LISTE *liste = tete, *temp;
char elementListe;

if ( liste->suivant != NULL){
if ( liste->suivant != NULL){
temp = liste->suivant;
liste->suivant = liste->suivant->suivant;
temp->suivant=NULL;
elementListe = temp->element;
}else{
temp = liste->suivant;
elementListe = temp->element;
temp->suivant=NULL;
}
delete temp;
}
*/

return liste[0];
}

//////////////////////////////////////////////////
//But : mettre l'équation en post fixée
//paramètre entré : tete la liste des noeuds
// pile la pile d'opérateur( +-/*^)
// listeOperante la liste des variables
////////////////////////////////////////////

void MettreEnPostFixe( char pile[255], char listeOperante[255], char tete[255], int &nbElementPile,
int &nbElementListeOperante, int NbValeurLu){

// LISTE* liste = tete;

int compteur = 0, nbLettre = 0,nbOperateur=0;
while(NbValeurLu > compteur){
if ( isalpha(tete[compteur]) == 1 && tete[compteur] != '='){
listeOperante[nbElementListeOperante++] = tete[compteur];
nbLettre++;
//InsererListe(listeOperante, tete[0]);
}else{

PlacerOperateur(listeOperante, pile, tete[compteur], nbElementPile, nbElementListeOperante, NbValeurLu);
nbOperateur++;
nbLettre=nbElementListeOperante;
// (nbElementPile)++;
}
compteur++;
//liste=liste->suivant;
}

/* if ( nbLettre != nbOperateur +1){
cerr << "Le nombre d'élément est invalide..."<<endl;
exit(1);
}
*/ if ( compteur > 5 ) compteur--;
else compteur--;
while(pile[0] != 0){
listeOperante[nbLettre++] = pile[nbElementPile-1];
pile[nbElementPile-1]=0;
nbElementPile--;
// compteur++;
nbElementListeOperante++;

//InsererListe(listeOperante, ObtenirPremierElement(pile));
}
}
//////////////////////////////////////////////////
//But : vérifie si j'ai bien un bon opérateur
//paramètre entré : opérateur à tester
//retour : true si l'élément est bien un opérateur
// false si l'élément n'est pas un opérateur
////////////////////////////////////////////

bool IsValideOperator(char element){

if (element != '+' || element != '-' || element != '/' || element != '*' || element != '^' || element != ';')
return true ;
return false;
}

//////////////////////////////////////////////////
//But : obtenir un élément de la liste
//paramètre entré : tete la liste des noeuds
// i le numéro du noeud
//retour : le caractère du noeud i de la liste
////////////////////////////////////////////

char ObtenirUnNoeud(char liste[255], int i ){

/* LISTE* liste = tete;
int compteur=1;
for( ; liste->suivant != NULL; liste = liste->suivant){

if ( compteur++ == i) return liste->element ;
}
return '-1';*/

return liste[i];
}

//////////////////////////////////////////////////
//But : afficher les informations en langage machine
//paramètre entré : tete la liste des noeuds
////////////////////////////////////////////

void Affichage(char liste[255],int nbElement){

// LISTE *liste = tete ;
bool Variable[10];
char arg1, arg2;
int numero_noeud = -1;
bool op ;
int i ,posArg1;
int compteur = 0 ;
int EmplacementRD, EmplacementRA;
for ( i = 0 ; i <10;++i){
Variable[i]=false;
}
//liste = tete;
// InsererListe(liste, '-1');
while(nbElement >= 1){
EmplacementRD =100;
EmplacementRA = 100;
++numero_noeud;
op=false;
/* while ( IsValideOperator(liste->element) == false){
arg1=liste->element ;
liste=liste->suivant ;
arg2 = liste->element ;
liste=liste->suivant ;
}*/
if ( IsValideOperator(liste[numero_noeud]) == true ){
switch(liste[numero_noeud]){
case 43/*'+'*/:
cout << "ADD " ;
op=true;

for ( i = 0 ; i <=9 ; i++) {
if ( Variable[i] == true ) break;
}
if ( i == 10 ) Variable[0] = true;
else Variable[i+1] = true;
if ( numero_noeud == 3 )
arg1= liste[1];
if ( i == 10 && Variable[i-1] == false ){
if( (arg1 = liste[numero_noeud-2]) == -1){
cerr <<"Erreur lors de l'obtention de la variable.";
exit(1);
}
}else EmplacementRD=i;
posArg1 = numero_noeud-2;
for ( i = 1 ; i <=9 ; i++) {
if ( Variable[i] == true ) break;
}
if ( i == 10 && Variable[i-1] == false ){
if ( (arg2 = liste[numero_noeud-1]) == -1){
cerr <<"Erreur lors de l'obtention de la variable.";
exit(1);
}
if ( i == 10 ) cout <<"R0";
else cout <<"R"<<i;
cout << " , "<<arg1 <<" "<<arg2<<endl;
posArg1 = numero_noeud-2;
if ( i == 10 ) Variable[0] = true ;
else Variable[i+1] = true ;
break;
}else{
EmplacementRA = i;
//Variable[EmplacementRA] = false;
}
EmplacementRA = i;
if ( EmplacementRD < 10 && EmplacementRA < 10 ){
cout << "R"<<EmplacementRD<<", R"<<EmplacementRD << " R"<<EmplacementRA<<endl;
Variable[i] = true ;
if ( liste[EmplacementRA] == '='){
liste[1] = liste[2];
posArg1 =2;
}
else{
liste[numero_noeud] = liste[nbElement];
posArg1 = EmplacementRA;
}
nbElement--;
Variable[i] = true ;
break;
}
for( i =0 ; i <=9 ; ++i) {
if ( Variable[i] == false) break;

cout <<"R"<<i;
cout << " , "<<"R"<<i<<" "<<arg2<<endl;
posArg1 = numero_noeud;

}
posArg1 = numero_noeud-1;
Variable[i] = true;

for ( i = 0 ; i <=9 ; i++)
if ( Variable[i] == true ) break;
cout <<"R"<<i<<",";
cout <<"R"<<i;
cout << " , "<<arg1 <<endl;
Variable[i] = true ;
break;
case 45/*-'*/:
cout << "SOU " ;
op=true;
for ( i = 0 ; i <=9 ; i++) {
if ( Variable[i] == true ) break;
}
if ( i == 10 && Variable[i-1] == false ){
if ( (arg1 = liste[numero_noeud-2]) == -1){
cerr <<"Erreur lors de l'obtention de la variable.";
exit(1);
}
}else EmplacementRD=i;
posArg1 =numero_noeud-2 ;
for ( i = 1 ; i <=9 ; i++) {
if ( Variable[i] == true ) break;
}
if ( i == 10 && Variable[i-1] == false ){
if ( (arg2 = liste[numero_noeud-1]) == -1){
cerr <<"Erreur lors de l'obtention de la variable.";
exit(1);
}

if ( EmplacementRD != 100){
if ( i == 10 ) cout << "R0";
else cout <<"R"<<i;
cout << " , R"<<EmplacementRD<<" "<<arg2<<endl;
posArg1 = numero_noeud-1;

}else{
cout <<"R"<<i;
cout << " , "<<arg1 <<" "<<arg2<<endl;
}
break;
}else{
EmplacementRA = i;
//Variable[EmplacementRA] = false;
}
if ( EmplacementRD < 10 && EmplacementRA < 10 ){
cout << "R"<<EmplacementRD<<", R"<<EmplacementRD << " R"<<EmplacementRA<<endl;
liste[numero_noeud] = liste[nbElement];
nbElement--;
break;
}
for( i =0 ; i <=9 ; ++i)
if ( Variable[i] == false) break;
Variable[i] = true;
cout <<"R"<<i;
cout << " , "<<arg1 <<" "<<arg2<<endl;
posArg1 = numero_noeud-2;

break;
case 42/*'*'*/:
cout << "MUL " ;
op=true;
for ( i = 0 ; i <=9; i++) {
if ( Variable[i] == true ) break;
}
if ( i == 10 && Variable[i-1] == false ){
if ( (arg1 = liste[numero_noeud-2]) == -1){
cerr <<"Erreur lors de l'obtention de la variable.";
exit(1);
}
}else{
if (liste[numero_noeud+1]== '+' || liste[numero_noeud+1] =='-'
|| liste[numero_noeud+1] == '*' || liste[numero_noeud+1] == '/'
|| liste[numero_noeud+1] == '^'){
if ( (arg1 = liste[numero_noeud-2]) == -1){
cerr <<"Erreur lors de l'obtention de la variable.";
exit(1);
}
}
else
EmplacementRD=i;
}

posArg1 = numero_noeud-2;
for ( i = 1 ; i <=9 ; i++) {
if ( Variable[i] == true ) break;
}
if ( i == 10 && Variable[i-1] == false ){
if ( (arg2 = liste[numero_noeud-1]) == -1){
cerr <<"Erreur lors de l'obtention de la variable.";
exit(1);
}
}else{
if ( i == 10 && Variable[i-1] == false ){
if ( (arg2 = liste[numero_noeud-1]) == -1){
cerr <<"Erreur lors de l'obtention de la variable.";
exit(1);
}

}else{
EmplacementRA = i;
//Variable[EmplacementRA] = false;
}
}
if ( EmplacementRD < 10 && EmplacementRA < 10 ){
cout << "R"<<EmplacementRD<<", R"<<EmplacementRD << " R"<<EmplacementRA<<endl;
liste[numero_noeud] = liste[nbElement];
nbElement--;
break;
}
for( i =0 ; i <=9 ; ++i)
if ( Variable[i] == false) break;
if ( i == 10 ) cout <<"R0";
else cout <<"R"<<i;
cout << " , "<<arg1 <<" "<<arg2<<endl;
posArg1 = numero_noeud-2;
for( i = 0 ; i < 10 ; i++)
if ( Variable[i] == false ) break;
Variable[i] = true ;
//}
break;
case 47 /*'/'*/:
cout << "DIV " ;
op=true;
for ( i = 0 ; i <=9 ; i++) {
if ( Variable[i] == true ) break;
}
if ( i == 10 ) Variable[0] = true;
else{
if ( i + 1 <= 10)
Variable[i+1] = true;
}
EmplacementRD=i;
if ( i == 10 && Variable[i-1] == false ){
if ( (arg1 = liste[numero_noeud-2]) == -1){
cerr <<"Erreur lors de l'obtention de la variable.";
exit(1);
}
}else{
if (liste[numero_noeud+1]== '+' || liste[numero_noeud+1] =='-'
|| liste[numero_noeud+1] == '*' || liste[numero_noeud+1] == '/'
|| liste[numero_noeud+1] == '^'){
if ( (arg1 = liste[numero_noeud-2]) == -1){
cerr <<"Erreur lors de l'obtention de la variable.";
exit(1);
}
EmplacementRD=i;
}
else
EmplacementRD=i;
}

for ( i = 1 ; i <=9 ; i++) {
if ( Variable[i] == true ) break;
}
if ( i == 10 && Variable[i-1] == false ){
if ( (arg2 = liste[numero_noeud-1]) == -1){
cerr <<"Erreur lors de l'obtention de la variable.";
exit(1);
}
if ( EmplacementRD == 10) cout <<"R0";
else cout <<"R"<<i;
cout << " , "<<arg1 <<" "<<arg2<<endl;
posArg1 = numero_noeud-2;
break;
}else{
EmplacementRA = i;
//Variable[EmplacementRA] = false;
if ( EmplacementRD == 10) cout <<"R0";
else cout <<"R"<<i;
cout <<", R" << EmplacementRD <<" R"<<EmplacementRA<<endl;
posArg1 = numero_noeud-2;
if (EmplacementRA!=100) Variable[EmplacementRA] = false;
posArg1 = EmplacementRA;
break;
}
if ( i == 10 ) Variable[0] = true;
else{
if ( i + 1 <= 10)
Variable[i+1] = true;
}

cout <<"R"<<i;
cout << " , "<<arg1 <<" "<<arg2<<endl;
posArg1 = numero_noeud-2;
Variable[i] = true;
break;
case 94/*'^'-*/:
cout << "EXP " ;
op=true;
for ( i = 0 ; i <=9 ; i++) {
if ( Variable[i] == true ){
break;
}
}
if ( i == 10 ) Variable[0] = true;
else{
if ( i + 1 <= 10)
Variable[i+1] = true;
else{
cerr << "Manque de registres."<<endl;
exit(1);
}
}

if ( i == 10 && Variable[i-1] == 0 || IsValideOperator(liste[numero_noeud+1])){
if ( (arg1 = liste[numero_noeud-2]) == -1){
cerr <<"Erreur lors de l'obtention de la variable.";
exit(1);
}
posArg1 = numero_noeud-2;
if ( i == 10 ) Variable[0] = true;
else{
if ( i + 1 <= 10)
Variable[i+1] = true;
}
EmplacementRD=i;
}else EmplacementRD=i;

for ( i = 1 ; i <=9 ; i++) {
if ( Variable[i] == true ) break;
}
if ( i == 10 && Variable[i-1] == false || IsValideOperator(liste[numero_noeud+1])){
if ( (arg2 = liste[numero_noeud-1]) == -1){
cerr <<"Erreur lors de l'obtention de la variable.";
exit(1);
}
if ( EmplacementRD == 10)
cout <<"R0";
else
cout <<"R"<< i;
cout << " , "<<arg1 <<" "<<arg2<<endl;
break;
}else{
EmplacementRA = i;
//Variable[EmplacementRA] = false;
}
if ( EmplacementRD < 10 && EmplacementRA < 10 ){
cout << "R"<<EmplacementRD<<", R"<<EmplacementRD << " R"<<EmplacementRA<<endl;
liste[numero_noeud] = liste[nbElement];
nbElement--;
break;
}
posArg1 = numero_noeud-2;
for( i =0 ; i <=9 ; ++i)
if ( Variable[i] == false) break;
Variable[i]=true;
if ( EmplacementRD <= 10) cout <<"R"<<i;
else cout <<"R0";
cout << " , "<<arg1 <<" "<<arg2<<endl;
posArg1 = numero_noeud-2;
Variable[0] = true ;
break;
case 61 /*'='*/:
cout << "AFF " ;
op=true;
if ( (arg1 = liste[numero_noeud-1]) == -1){
cerr <<"Erreur lors de l'obtention de la variable.";
exit(1);
}

for ( i = 0 ; i <=9 ; i++) {
if ( Variable[i] == true ) break;
}
if ( i == 10 && Variable[i] == false ){
if ( (arg2 = liste[numero_noeud-1]) == -1){
cerr <<"Erreur lors de l'obtention de la variable.";
exit(1);
}
cout <<"R"<<i;
cout << " , "<<arg1 <<" "<<arg2<<endl;
break;
}
cout <<arg1;
cout << " , "<<"R"<<i<<endl;

posArg1 = numero_noeud-1;

break;

};
if ( op == true){
if ( liste[2]!= '+' && liste[2] !='-' && liste[2] != '*' && liste[2] != '/' && liste[2] != '^'&& liste[2] != '=' ){
/*if ( liste[3]!= '+' && liste[3] !='-' && liste[3] != '*' && liste[3] != '/' && liste[3] != '^'&& liste[3] != '='
&& liste[3] != '1'){*/
liste[numero_noeud-2] = '-1';
liste[numero_noeud-1] = '-1';
liste[numero_noeud] = '-1';
/* }else{
liste[numero_noeud-1] = '-1';
if ( liste[numero_noeud+1] != '=')
liste[numero_noeud] = '-1';
}*/
}else{
if ( liste[2] != '=' )
liste[1]=liste[3];
else
liste[1]=liste[2];
posArg1++;
}
for (compteur = posArg1; compteur < nbElement ; compteur ++){
if ( compteur > 3|| posArg1 ==1)
liste[compteur]=liste[compteur+3];
/*else
if ( posArg1 == 1)
liste[compteur+1]=liste[compteur+3];*/
else
liste[compteur]=liste[compteur+1];

}
nbElement-=2;
numero_noeud=-1;
}

}
}

}
//////////////////////////////////////////////////
//But : placer dans la pile au bon endroit l'opérateur(+-...)
//paramètre entré : tete la liste des noeuds
// pile la pile d'opérateur
// valeur : la valeur à ajouter dans la pile
////////////////////////////////////////////

void PlacerOperateur(char listeOperante[255], char pile[255], char liste, int &nbElementPile,
int &nbElementListeOperante, char valeur){

/* LISTE *Lpile = pile;
LISTE *Loperante = listeOperante;
LISTE *nouveau = new LISTE;
nouveau->element=valeur;
nouveau->suivant=NULL;
*/
bool ajout = false;
if ( liste == '('){
pile[nbElementPile++] = liste;
//InsererListe(listeOperante, valeur);
}
if ( liste == ')'){
while(pile[nbElementPile] != '('){
pile[(nbElementPile)++] == liste;
;
//InsererListe(listeOperante, valeur);
// Supprimer(pile);
}

}
while ( !EstVide(pile) && ObtenirPremierElement(pile) != '(' &&
PrioriteOperateur(liste) < PrioriteOperateur( pile[nbElementPile-1] )){
listeOperante[nbElementListeOperante] = pile[nbElementPile-1];
pile[(nbElementPile)] = '-1';
nbElementListeOperante++;
nbElementPile--;
//InsererListe(listeOperante, pile[sizeof(pile)]);
// Supprimer(pile);
pile[(nbElementPile)++]=liste;
ajout = true;
// InsererListe(pile, valeur);
// Supprimer(pile);
}
if ( ajout == false) pile[(nbElementPile)++]=liste;
}

//////////////////////////////////////////////////
//But : affchier le contenu de la liste des noeuds à l'écran
//paramètre entré : tete la liste des noeuds
///////////////////////////////////////////

void AfficherListe(char element[255], int nbElement){

for( int compteur = 0 ;compteur <nbElement ; ++compteur){
cout << element[compteur]<<endl;
}

}
//////////////////////////////////////////////////
//But : supprimer le dernier noeud de la liste de noeud
//paramètre entré : tete la liste des noeuds
////////////////////////////////////////////
/*
void Supprimer(LISTE* tete){

LISTE *liste = tete;
LISTE *temp;

for(liste = liste->suivant ; liste->suivant->suivant != NULL ; liste = liste->suivant) ;

temp = liste->suivant->suivant;
liste->suivant = NULL;

delete temp;
}*/

//////////////////////////////////////////////////
//But : obtenir la priorité d'un opérateur
//paramètre entré : op l'opérateur à tester
//retour : entre 0 et 2 si l'opérateur est valide
// -1 dans le cas contraire
////////////////////////////////////////////

int PrioriteOperateur(char op){
if ( op != '+' && op != '-' && op != '/' && op != '*' && op != '^' && op != '=')
return -1;

/*
= priorité 0
+ - priorité 1
* / priorité 2
^ priorité 3
*/

switch ( op){
case 61/*'='*/:return 0;
break;
case 43/*'+'*/:
case 45 /*'-'*/: return 1;
break;
case 47/*'/'*/:
case 42/*'*'*/: return 2;
break;
case 94/*'^'*/: return 3;
break;
};

return -1 ;
}

//////////////////////////////////////////////////
//But : fonction principale
////////////////////////////////////////////

int main(){

char element[255];
char pile[255];
char listeOperante[255];
int nbElementPile = 0;
int nbElementListeOperante = 0;
int nbElementLu = 0;
for (int i = 0 ; i < 255;i++){
element[i]=0;
//listeOperante[i]=0;
//pile[i]=0;
}
/* listeOperante->element='-1';
listeOperante->suivant=NULL;
pile->element='-1';
pile->suivant=NULL;*/
nbElementLu = LireFichier(element);
cout << "Afficher la liste apres lecteure du fichier..."<<endl;
AfficherListe(element,nbElementLu);
MettreEnPostFixe(pile, listeOperante, element,nbElementPile, nbElementListeOperante,nbElementLu);
cout << "Afficher la pile"<<endl;
AfficherListe(pile,nbElementPile);
cout << "Afficher la liste des opérante..."<<endl;
AfficherListe(listeOperante,nbElementListeOperante);
Affichage(listeOperante, nbElementListeOperante);

return 0;
}

<fin>

contenu du fichier

A= A + B

normalement je devrai avoir ceci à l'écran

ADD R0, A B
AFF A, R0

R0 est un registre.. j'en aie 10 en tout ( 0-9)..

merci
mousekey
0
mamiemando Messages postés 33869 Date d'inscription   Statut Modérateur Dernière intervention   7 902
 
C'est comme ça que tu encadres le code de balises < code > < /code > (comme en html) ? Sélectionne le code à la souris et clique sur le bouton code (à droite des bouton gras/italique/souligé, au dessus de la boîte ou tu saisis ton message). Dans ton aperçu ça doit donner ça 
int main(){
   return 0;
}

Si on n'y voit rien difficile de t'aider ;-)
0
Réponse 3 / 5
bacchuss Messages postés 1165 Statut Membre 190
  
/////////////////////////////////////////////////////////
//But: mettre une équation en post fixée.
//Auteur : Eric Soulard
//Date de création : 14 novembre 2005
//dernière modification :
/////////////////////////////////////


#include <iostream>
#include <cstdlib>
#include <fstream>
#include <string>
#include <ctype.h>

using namespace std;




struct LISTE{
char element;
LISTE *suivant;
};
void AfficherListe(char element[255], int nbElement);
// void SupprimerUnNoeud(char liste[255], int numero_noeud);
char ObtenirUnNoeud(char liste[255], int i );
int LireFichier(char element[255]);
bool EstVide(char liste[255]);
char ObtenirPremierElement(char liste[255]);
void MettreEnPostFixe(char liste[255], char listeOperante[255], int &nbElementPile,
int &nbElementListeOperante, int nbCarLu);
int PrioriteOperateur(char op);
void AfficherResultat(char liste[255]);
void InsererListe(char liste[255], char valeur);
//void Supprimer(char liste[255]);
int LireFichier(void);
void PlacerOperateur(char listeOperante[255], char pile[255], char liste, int &nbElementPile,
int &nbElementListeOperante, char valeur);
int PrioriteOperateur(char op);


//////////////////////////////////////////////////
//But : insérer un nouveau noeud à la fin de la liste.
//paramètre entré : tete la liste des noeuds
// valeur : la valeur à insérer dans la liste
////////////////////////////////////////////

void InsererListe(char liste[255], char valeur){

// LISTE *liste = tete, *nouveau = new LISTE;
//nouveau->element=valeur;
//nouveau->suivant=NULL;

/*for( ; liste->suivant != NULL; liste= liste->suivant);

if ( liste->suivant == NULL)
liste = nouveau;
else{
cerr << "Erreur lors de l'ajout";
exit(1);
}
*/
}


//////////////////////////////////////////////////
//But : supprimer un noeud en particulier dans la liste
//paramètre entré : tete la liste des noeuds
// numero_noeau : le numéro du noeud à enlever
////////////////////////////////////////////



//////////////////////////////////////////////////
//But : lire le fichier
//paramètre entré : tete la liste des noeuds
////////////////////////////////////////////

int LireFichier(char element[255]){
ifstream fichier;
//char element;
// LISTE* liste = tete;

fichier.open("donnee.txt", ios::in);
int compteur = 0;
if ( !fichier){
cerr << "Erreur lors de l'ouverture du fichier donnee.txt";
exit(1);
}


//lire le nombre
// si le caractère lu est un nombre
//ajouter le nombre dans le tableau
//sinon afficher le message d'erreur à l'écran
fichier.getline(element,255,'\n');

element[strlen(element)+1]= '\0';

return strlen(element);

}
//////////////////////////////////////////////////
//But : vérifier si la liste est vide ou pas
//paramètre entré : tete la liste des noeuds
//retour : true si la liste est vide
// false si la liste est non vide
////////////////////////////////////////////

bool EstVide(char liste[255]){

return ( liste[0] == 0 );
}

//////////////////////////////////////////////////
//But : obtenir le dernier élément de la liste
//paramètre entré : tete la liste des noeuds
//retour : le caractère du dernier noeud de la liste
////////////////////////////////////////////


char ObtenirDernierElement(char liste[255], int taille){

/* if ( tete == NULL ) return '-';
LISTE *liste = tete, *temp;
char elementListe;


for ( liste ; liste->suivant != NULL ; liste = liste->suivant);

if ( liste->suivant != NULL){
temp = liste->suivant;
liste = liste->suivant;
temp->suivant=NULL;
delete temp;
}else{
delete liste;
}*/

return liste[taille];
}

//////////////////////////////////////////////////
//But : obtenir le premier élément de la liste
//paramètre entré : tete la liste des noeuds
//retour : le caractère du premier noeud de la liste
////////////////////////////////////////////

char ObtenirPremierElement(char liste[255]){

/*LISTE *liste = tete, *temp;
char elementListe;

if ( liste->suivant != NULL){
if ( liste->suivant != NULL){
temp = liste->suivant;
liste->suivant = liste->suivant->suivant;
temp->suivant=NULL;
elementListe = temp->element;
}else{
temp = liste->suivant;
elementListe = temp->element;
temp->suivant=NULL;
}
delete temp;
}
*/



return liste[0];
}

//////////////////////////////////////////////////
//But : mettre l'équation en post fixée
//paramètre entré : tete la liste des noeuds
// pile la pile d'opérateur( +-/*^)
// listeOperante la liste des variables
////////////////////////////////////////////

void MettreEnPostFixe( char pile[255], char listeOperante[255], char tete[255], int &nbElementPile,
int &nbElementListeOperante, int NbValeurLu){

// LISTE* liste = tete;

int compteur = 0, nbLettre = 0,nbOperateur=0;
while(NbValeurLu > compteur){
if ( isalpha(tete[compteur]) == 1 && tete[compteur] != '='){
listeOperante[nbElementListeOperante++] = tete[compteur];
nbLettre++;
//InsererListe(listeOperante, tete[0]);
}else{


PlacerOperateur(listeOperante, pile, tete[compteur], nbElementPile, nbElementListeOperante, NbValeurLu);
nbOperateur++;
nbLettre=nbElementListeOperante;
// (nbElementPile)++;
}
compteur++;
//liste=liste->suivant;
}

/* if ( nbLettre != nbOperateur +1){
cerr << "Le nombre d'élément est invalide..."<<endl;
exit(1);
}
*/ if ( compteur > 5 ) compteur--;
else compteur--;
while(pile[0] != 0){
listeOperante[nbLettre++] = pile[nbElementPile-1];
pile[nbElementPile-1]=0;
nbElementPile--;
// compteur++;
nbElementListeOperante++;

//InsererListe(listeOperante, ObtenirPremierElement(pile));
}
}
//////////////////////////////////////////////////
//But : vérifie si j'ai bien un bon opérateur
//paramètre entré : opérateur à tester
//retour : true si l'élément est bien un opérateur
// false si l'élément n'est pas un opérateur
////////////////////////////////////////////

bool IsValideOperator(char element){

if (element != '+' || element != '-' || element != '/' || element != '*' || element != '^' || element != ';')
return true ;
return false;
}

//////////////////////////////////////////////////
//But : obtenir un élément de la liste
//paramètre entré : tete la liste des noeuds
// i le numéro du noeud
//retour : le caractère du noeud i de la liste
////////////////////////////////////////////


char ObtenirUnNoeud(char liste[255], int i ){

/* LISTE* liste = tete;
int compteur=1;
for( ; liste->suivant != NULL; liste = liste->suivant){

if ( compteur++ == i) return liste->element ;
}
return '-1';*/

return liste[i];
}

//////////////////////////////////////////////////
//But : afficher les informations en langage machine
//paramètre entré : tete la liste des noeuds
////////////////////////////////////////////

void Affichage(char liste[255],int nbElement){

// LISTE *liste = tete ;
bool Variable[10];
char arg1, arg2;
int numero_noeud = -1;
bool op ;
int i ,posArg1;
int compteur = 0 ;
int EmplacementRD, EmplacementRA;
for ( i = 0 ; i <10;++i){
Variable[i]=false;
}
//liste = tete;
// InsererListe(liste, '-1');
while(nbElement >= 1){
EmplacementRD =100;
EmplacementRA = 100;
++numero_noeud;
op=false;
/* while ( IsValideOperator(liste->element) == false){
arg1=liste->element ;
liste=liste->suivant ;
arg2 = liste->element ;
liste=liste->suivant ;
}*/
if ( IsValideOperator(liste[numero_noeud]) == true ){
switch(liste[numero_noeud]){
case 43/*'+'*/:
cout << "ADD " ;
op=true;

for ( i = 0 ; i <=9 ; i++) {
if ( Variable[i] == true ) break;
}
if ( i == 10 ) Variable[0] = true;
else Variable[i+1] = true;
if ( numero_noeud == 3 )
arg1= liste[1];
if ( i == 10 && Variable[i-1] == false ){
if( (arg1 = liste[numero_noeud-2]) == -1){
cerr <<"Erreur lors de l'obtention de la variable.";
exit(1);
}
}else EmplacementRD=i;
posArg1 = numero_noeud-2;
for ( i = 1 ; i <=9 ; i++) {
if ( Variable[i] == true ) break;
}
if ( i == 10 && Variable[i-1] == false ){
if ( (arg2 = liste[numero_noeud-1]) == -1){
cerr <<"Erreur lors de l'obtention de la variable.";
exit(1);
}
if ( i == 10 ) cout <<"R0";
else cout <<"R"<<i;
cout << " , "<<arg1 <<" "<<arg2<<endl;
posArg1 = numero_noeud-2;
if ( i == 10 ) Variable[0] = true ;
else Variable[i+1] = true ;
break;
}else{
EmplacementRA = i;
//Variable[EmplacementRA] = false;
}
EmplacementRA = i;
if ( EmplacementRD < 10 && EmplacementRA < 10 ){
cout << "R"<<EmplacementRD<<", R"<<EmplacementRD << " R"<<EmplacementRA<<endl;
Variable[i] = true ;
if ( liste[EmplacementRA] == '='){
liste[1] = liste[2];
posArg1 =2;
}
else{
liste[numero_noeud] = liste[nbElement];
posArg1 = EmplacementRA;
}
nbElement--;
Variable[i] = true ;
break;
}
for( i =0 ; i <=9 ; ++i) {
if ( Variable[i] == false) break;

cout <<"R"<<i;
cout << " , "<<"R"<<i<<" "<<arg2<<endl;
posArg1 = numero_noeud;

}
posArg1 = numero_noeud-1;
Variable[i] = true;

for ( i = 0 ; i <=9 ; i++)
if ( Variable[i] == true ) break;
cout <<"R"<<i<<",";
cout <<"R"<<i;
cout << " , "<<arg1 <<endl;
Variable[i] = true ;
break;
case 45/*-'*/:
cout << "SOU " ;
op=true;
for ( i = 0 ; i <=9 ; i++) {
if ( Variable[i] == true ) break;
}
if ( i == 10 && Variable[i-1] == false ){
if ( (arg1 = liste[numero_noeud-2]) == -1){
cerr <<"Erreur lors de l'obtention de la variable.";
exit(1);
}
}else EmplacementRD=i;
posArg1 =numero_noeud-2 ;
for ( i = 1 ; i <=9 ; i++) {
if ( Variable[i] == true ) break;
}
if ( i == 10 && Variable[i-1] == false ){
if ( (arg2 = liste[numero_noeud-1]) == -1){
cerr <<"Erreur lors de l'obtention de la variable.";
exit(1);
}

if ( EmplacementRD != 100){
if ( i == 10 ) cout << "R0";
else cout <<"R"<<i;
cout << " , R"<<EmplacementRD<<" "<<arg2<<endl;
posArg1 = numero_noeud-1;

}else{
cout <<"R"<<i;
cout << " , "<<arg1 <<" "<<arg2<<endl;
}
break;
}else{
EmplacementRA = i;
//Variable[EmplacementRA] = false;
}
if ( EmplacementRD < 10 && EmplacementRA < 10 ){
cout << "R"<<EmplacementRD<<", R"<<EmplacementRD << " R"<<EmplacementRA<<endl;
liste[numero_noeud] = liste[nbElement];
nbElement--;
break;
}
for( i =0 ; i <=9 ; ++i)
if ( Variable[i] == false) break;
Variable[i] = true;
cout <<"R"<<i;
cout << " , "<<arg1 <<" "<<arg2<<endl;
posArg1 = numero_noeud-2;

break;
case 42/*'*'*/:
cout << "MUL " ;
op=true;
for ( i = 0 ; i <=9; i++) {
if ( Variable[i] == true ) break;
}
if ( i == 10 && Variable[i-1] == false ){
if ( (arg1 = liste[numero_noeud-2]) == -1){
cerr <<"Erreur lors de l'obtention de la variable.";
exit(1);
}
}else{
if (liste[numero_noeud+1]== '+' || liste[numero_noeud+1] =='-'
|| liste[numero_noeud+1] == '*' || liste[numero_noeud+1] == '/'
|| liste[numero_noeud+1] == '^'){
if ( (arg1 = liste[numero_noeud-2]) == -1){
cerr <<"Erreur lors de l'obtention de la variable.";
exit(1);
}
}
else
EmplacementRD=i;
}

posArg1 = numero_noeud-2;
for ( i = 1 ; i <=9 ; i++) {
if ( Variable[i] == true ) break;
}
if ( i == 10 && Variable[i-1] == false ){
if ( (arg2 = liste[numero_noeud-1]) == -1){
cerr <<"Erreur lors de l'obtention de la variable.";
exit(1);
}
}else{
if ( i == 10 && Variable[i-1] == false ){
if ( (arg2 = liste[numero_noeud-1]) == -1){
cerr <<"Erreur lors de l'obtention de la variable.";
exit(1);
}

}else{
EmplacementRA = i;
//Variable[EmplacementRA] = false;
}
}
if ( EmplacementRD < 10 && EmplacementRA < 10 ){
cout << "R"<<EmplacementRD<<", R"<<EmplacementRD << " R"<<EmplacementRA<<endl;
liste[numero_noeud] = liste[nbElement];
nbElement--;
break;
}
for( i =0 ; i <=9 ; ++i)
if ( Variable[i] == false) break;
if ( i == 10 ) cout <<"R0";
else cout <<"R"<<i;
cout << " , "<<arg1 <<" "<<arg2<<endl;
posArg1 = numero_noeud-2;
for( i = 0 ; i < 10 ; i++)
if ( Variable[i] == false ) break;
Variable[i] = true ;
//}
break;
case 47 /*'/'*/:
cout << "DIV " ;
op=true;
for ( i = 0 ; i <=9 ; i++) {
if ( Variable[i] == true ) break;
}
if ( i == 10 ) Variable[0] = true;
else{
if ( i + 1 <= 10)
Variable[i+1] = true;
}
EmplacementRD=i;
if ( i == 10 && Variable[i-1] == false ){
if ( (arg1 = liste[numero_noeud-2]) == -1){
cerr <<"Erreur lors de l'obtention de la variable.";
exit(1);
}
}else{
if (liste[numero_noeud+1]== '+' || liste[numero_noeud+1] =='-'
|| liste[numero_noeud+1] == '*' || liste[numero_noeud+1] == '/'
|| liste[numero_noeud+1] == '^'){
if ( (arg1 = liste[numero_noeud-2]) == -1){
cerr <<"Erreur lors de l'obtention de la variable.";
exit(1);
}
EmplacementRD=i;
}
else
EmplacementRD=i;
}


for ( i = 1 ; i <=9 ; i++) {
if ( Variable[i] == true ) break;
}
if ( i == 10 && Variable[i-1] == false ){
if ( (arg2 = liste[numero_noeud-1]) == -1){
cerr <<"Erreur lors de l'obtention de la variable.";
exit(1);
}
if ( EmplacementRD == 10) cout <<"R0";
else cout <<"R"<<i;
cout << " , "<<arg1 <<" "<<arg2<<endl;
posArg1 = numero_noeud-2;
break;
}else{
EmplacementRA = i;
//Variable[EmplacementRA] = false;
if ( EmplacementRD == 10) cout <<"R0";
else cout <<"R"<<i;
cout <<", R" << EmplacementRD <<" R"<<EmplacementRA<<endl;
posArg1 = numero_noeud-2;
if (EmplacementRA!=100) Variable[EmplacementRA] = false;
posArg1 = EmplacementRA;
break;
}
if ( i == 10 ) Variable[0] = true;
else{
if ( i + 1 <= 10)
Variable[i+1] = true;
}

cout <<"R"<<i;
cout << " , "<<arg1 <<" "<<arg2<<endl;
posArg1 = numero_noeud-2;
Variable[i] = true;
break;
case 94/*'^'-*/:
cout << "EXP " ;
op=true;
for ( i = 0 ; i <=9 ; i++) {
if ( Variable[i] == true ){
break;
}
}
if ( i == 10 ) Variable[0] = true;
else{
if ( i + 1 <= 10)
Variable[i+1] = true;
else{
cerr << "Manque de registres."<<endl;
exit(1);
}
}

if ( i == 10 && Variable[i-1] == 0 || IsValideOperator(liste[numero_noeud+1])){
if ( (arg1 = liste[numero_noeud-2]) == -1){
cerr <<"Erreur lors de l'obtention de la variable.";
exit(1);
}
posArg1 = numero_noeud-2;
if ( i == 10 ) Variable[0] = true;
else{
if ( i + 1 <= 10)
Variable[i+1] = true;
}
EmplacementRD=i;
}else EmplacementRD=i;

for ( i = 1 ; i <=9 ; i++) {
if ( Variable[i] == true ) break;
}
if ( i == 10 && Variable[i-1] == false || IsValideOperator(liste[numero_noeud+1])){
if ( (arg2 = liste[numero_noeud-1]) == -1){
cerr <<"Erreur lors de l'obtention de la variable.";
exit(1);
}
if ( EmplacementRD == 10)
cout <<"R0";
else
cout <<"R"<< i;
cout << " , "<<arg1 <<" "<<arg2<<endl;
break;
}else{
EmplacementRA = i;
//Variable[EmplacementRA] = false;
}
if ( EmplacementRD < 10 && EmplacementRA < 10 ){
cout << "R"<<EmplacementRD<<", R"<<EmplacementRD << " R"<<EmplacementRA<<endl;
liste[numero_noeud] = liste[nbElement];
nbElement--;
break;
}
posArg1 = numero_noeud-2;
for( i =0 ; i <=9 ; ++i)
if ( Variable[i] == false) break;
Variable[i]=true;
if ( EmplacementRD <= 10) cout <<"R"<<i;
else cout <<"R0";
cout << " , "<<arg1 <<" "<<arg2<<endl;
posArg1 = numero_noeud-2;
Variable[0] = true ;
break;
case 61 /*'='*/:
cout << "AFF " ;
op=true;
if ( (arg1 = liste[numero_noeud-1]) == -1){
cerr <<"Erreur lors de l'obtention de la variable.";
exit(1);
}

for ( i = 0 ; i <=9 ; i++) {
if ( Variable[i] == true ) break;
}
if ( i == 10 && Variable[i] == false ){
if ( (arg2 = liste[numero_noeud-1]) == -1){
cerr <<"Erreur lors de l'obtention de la variable.";
exit(1);
}
cout <<"R"<<i;
cout << " , "<<arg1 <<" "<<arg2<<endl;
break;
}
cout <<arg1;
cout << " , "<<"R"<<i<<endl;



posArg1 = numero_noeud-1;

break;

};
if ( op == true){
if ( liste[2]!= '+' && liste[2] !='-' && liste[2] != '*' && liste[2] != '/' && liste[2] != '^'&& liste[2] != '=' ){
/*if ( liste[3]!= '+' && liste[3] !='-' && liste[3] != '*' && liste[3] != '/' && liste[3] != '^'&& liste[3] != '='
&& liste[3] != '1'){*/
liste[numero_noeud-2] = '-1';
liste[numero_noeud-1] = '-1';
liste[numero_noeud] = '-1';
/* }else{
liste[numero_noeud-1] = '-1';
if ( liste[numero_noeud+1] != '=')
liste[numero_noeud] = '-1';
}*/
}else{
if ( liste[2] != '=' )
liste[1]=liste[3];
else
liste[1]=liste[2];
posArg1++;
}
for (compteur = posArg1; compteur < nbElement ; compteur ++){
if ( compteur > 3|| posArg1 ==1)
liste[compteur]=liste[compteur+3];
/*else
if ( posArg1 == 1)
liste[compteur+1]=liste[compteur+3];*/
else
liste[compteur]=liste[compteur+1];

}
nbElement-=2;
numero_noeud=-1;
}


}
}


}
//////////////////////////////////////////////////
//But : placer dans la pile au bon endroit l'opérateur(+-...)
//paramètre entré : tete la liste des noeuds
// pile la pile d'opérateur
// valeur : la valeur à ajouter dans la pile
////////////////////////////////////////////

void PlacerOperateur(char listeOperante[255], char pile[255], char liste, int &nbElementPile,
int &nbElementListeOperante, char valeur){


/* LISTE *Lpile = pile;
LISTE *Loperante = listeOperante;
LISTE *nouveau = new LISTE;
nouveau->element=valeur;
nouveau->suivant=NULL;
*/
bool ajout = false;
if ( liste == '('){
pile[nbElementPile++] = liste;
//InsererListe(listeOperante, valeur);
}
if ( liste == ')'){
while(pile[nbElementPile] != '('){
pile[(nbElementPile)++] == liste;
;
//InsererListe(listeOperante, valeur);
// Supprimer(pile);
}

}
while ( !EstVide(pile) && ObtenirPremierElement(pile) != '(' &&
PrioriteOperateur(liste) < PrioriteOperateur( pile[nbElementPile-1] )){
listeOperante[nbElementListeOperante] = pile[nbElementPile-1];
pile[(nbElementPile)] = '-1';
nbElementListeOperante++;
nbElementPile--;
//InsererListe(listeOperante, pile[sizeof(pile)]);
// Supprimer(pile);
pile[(nbElementPile)++]=liste;
ajout = true;
// InsererListe(pile, valeur);
// Supprimer(pile);
}
if ( ajout == false) pile[(nbElementPile)++]=liste;
}


//////////////////////////////////////////////////
//But : affchier le contenu de la liste des noeuds à l'écran
//paramètre entré : tete la liste des noeuds
///////////////////////////////////////////


void AfficherListe(char element[255], int nbElement){

for( int compteur = 0 ;compteur <nbElement ; ++compteur){
cout << element[compteur]<<endl;
}

}
//////////////////////////////////////////////////
//But : supprimer le dernier noeud de la liste de noeud
//paramètre entré : tete la liste des noeuds
////////////////////////////////////////////
/*
void Supprimer(LISTE* tete){

LISTE *liste = tete;
LISTE *temp;

for(liste = liste->suivant ; liste->suivant->suivant != NULL ; liste = liste->suivant) ;

temp = liste->suivant->suivant;
liste->suivant = NULL;

delete temp;
}*/

//////////////////////////////////////////////////
//But : obtenir la priorité d'un opérateur
//paramètre entré : op l'opérateur à tester
//retour : entre 0 et 2 si l'opérateur est valide
// -1 dans le cas contraire
////////////////////////////////////////////

int PrioriteOperateur(char op){
if ( op != '+' && op != '-' && op != '/' && op != '*' && op != '^' && op != '=')
return -1;

/*
= priorité 0
+ - priorité 1
* / priorité 2
^ priorité 3
*/

switch ( op){
case 61/*'='*/:return 0;
break;
case 43/*'+'*/:
case 45 /*'-'*/: return 1;
break;
case 47/*'/'*/:
case 42/*'*'*/: return 2;
break;
case 94/*'^'*/: return 3;
break;
};

return -1 ;
}


//////////////////////////////////////////////////
//But : fonction principale
////////////////////////////////////////////

int main(){

char element[255];
char pile[255];
char listeOperante[255];
int nbElementPile = 0;
int nbElementListeOperante = 0;
int nbElementLu = 0;
for (int i = 0 ; i < 255;i++){
element[i]=0;
//listeOperante[i]=0;
//pile[i]=0;
}
/* listeOperante->element='-1';
listeOperante->suivant=NULL;
pile->element='-1';
pile->suivant=NULL;*/
nbElementLu = LireFichier(element);
cout << "Afficher la liste apres lecteure du fichier..."<<endl;
AfficherListe(element,nbElementLu);
MettreEnPostFixe(pile, listeOperante, element,nbElementPile, nbElementListeOperante,nbElementLu);
cout << "Afficher la pile"<<endl;
AfficherListe(pile,nbElementPile);
cout << "Afficher la liste des opérante..."<<endl;
AfficherListe(listeOperante,nbElementListeOperante);
Affichage(listeOperante, nbElementListeOperante);


return 0;
}
0
Réponse 4 / 5
mamiemando Messages postés 33869 Date d'inscription   Statut Modérateur Dernière intervention   7 902
  
A*B-B^C

donne 
*
-
^
C
B
B
A

Si l'on a les priorités -<+<*<^
Ca devrait pas plutôt être : 
-
^
C
B
*
B
A


Aspect résultats :

En tout cas pour moi la notation polonaise postfixée c'est ça ;)
Dis-moi en fait ce que tu voudrais comme résultat (donne moi quelques expressions et le résultat que tu veux).

Aspect c++ :

Ensuite, comme tu fais du c++, pourquoi ne pas utiliser les std:string au lieu des char buf[255] (#include <string>) ?

De même pour les listes, pourquoi ne pas utiliser la classe std::vector ? (#include <vector>)

Voilà sinon évite de mettre des majuscules à tes noms de fonctions. Normalement c'est uniquement les objets qui ont une majuscules, et encore cette convention n'est qu'en java.

Je regarde ca plus en détail ce soir
0
mousekey
 
Bonjour,
j'y aie tout simplement pas pensé... j'ai pas l'habitude d'utilise la librairie std: string...
merci
mousekey
0

Vous n’avez pas trouvé la réponse que vous recherchez ?

Posez votre question
Réponse 5 / 5
mamiemando Messages postés 33869 Date d'inscription   Statut Modérateur Dernière intervention   7 902
 
Ok je viens de lire ton sujet normalement c'est bien A B * B C ^ -

Erratum : std::string et non std:string (faute de frappe de ma part). Vu comment est posé le sujet tu peux utiliser un char* car les strings n'apporteront rien. Evite juste les char[255] c'est laid, passe un char *. Par ailleurs je te suggère de regarder aussi comment marche les références en c++ pour tes passages de paramètres.

Vu comment le sujet est posé tu dois :
1) dans un premier temps écrire l'automate (analyseur syntaxique) qui te permet de lire, que tu as du voir en cours de compilation. Tu sais, le graphe avec un état initial, un ou plusieurs états finaux, et des états intermédiaires, que tu relie avec des transitions. Si tu ne vois pas de quoi je parle, cf cours de compilation ;)
2) écrire le programme c++ Naturellement sans l'automate je ne peux pas trop debugger ton programme

Chaque transition correspond en fait à une opération du compilateur (stockage dans une pile, etc...). Ces transitions sont souvent notée sigma_i (avec i un indice).

A chaque transition correspond une fonction auxquelles tu passeras en paramètre un objet qui contient la liste des registres et ta pile. Ces fonctions s'appèleront mutuellement en fonction du token lu (la manières dont elles s'appèlent découle du fameux graphe).

Pour chaque état tu dois traiter:
1) les tokens invalides (a+b*-... apres * on attend une lettre)
2) token noté '#' (\0 en C) correspondant à la fin de la chaine (s'il est rencontré à un état intermédiaire genre "a+b*c-#" l'expression est mal formée).
3) les tokens valides, qui vont déclencher une transition sigma, en n'oubliant pas de passer au token suivant.

Tes transitions auront donc la forme 
bool sigma_1(const std::string & expr,registres & r,pile & p){
 
  switch(token_lu){
     case '\0':
         return true;//si c'est un etat final
         return false; //si c'est un état intermédiaire
     case '1': case '2': .... case '9':
        //manipuler registres et pile...
        return sigma_2(expr+1,registres,pile);//expr+1 c'est pour dire de passer au token suivant mais ça ne doit pas compiler
     case '+':
        //...
        return sigma_3(expr+1,registres,pile);
     case '-':
        //...
   //...
     default: std::cerr<<"token invalide "<<token_lu<<std::endl;
        return false;
}


Quand tu arrives à une erreur syntaxique ou a un etat final, tu fais un return true ou false et hop tu vas retourner dans le main

Dans ton main tu initialises tout le bazar et tu te places dans l'état initial avec une fonction sigma_init par exemple. sigma_init ne sera quittée que quand tu auras trouvé une erreur syntaxique ou que tu auras fini de lire si tu as suivi le plan que je t'ai donné. 

int main(){
   registres r;  //tu peux utiliser la classe std::vector
   std::string s="A+B-C";
   pile p;  //tu peux utiliser la classe std::stack
   bool ok=sigma_init(s,r,p);
   if(ok) ecrire_resultats(p);
   else std::cerr<<"expression mal formee"<<std::endl;
   return 0;
}


Voilà désolé mais je peux par faire plus (d'une part parce que c'est ton job ! et d'autre part parce que je n'ai pas envie d'écrire l'automate). Tu as tout le framework, maintenant c'est tranquille ;)

Pour les std::vector et les std::stack :
http://www.sgi.com/tech/stl/stack.html
http://www.sgi.com/tech/stl/Vector.html

Bonne chance
0

Discussions similaires

compilateur c++ gratuit
sam -
eee -

31 réponses
ou trouver un site pour telecharger un compilateur cobol
mambgast -
Moi -

2 réponses
Je recherche un compilateur Cobol
Denis222 -
Denis222 -

2 réponses
[PasCaL] Compilateur Linux
Kurt77 -
Marmot -

2 réponses
trouver un compilateur fortran
oilv -
broheim -

8 réponses