STIVA

#pragma warning(disable:4786)
#include <deque>
#include <iostream>
#include <string>
using namespace std;
#include "ierarhie.h"
#include "stiva.h"
#include "fisier.h"
#include "coada.h"
///Variabile globale
fisier f;
stiva <char> OPER;
stiva <double> EVAL;
coada POSTFIX;
void eroare(const char * text,int nr){
 cout<<"\n"<<text<<"\n";
 exit(nr);
}
void scrierePOSTFIX(string &op)
{
 char opc;
 if(op=="")
 return;
 int ierOp=ierarhie(op);
 ///daca e valoare, se trece direct in scrierea postfixata
 if(!ierOp)
 POSTFIX.adauga(op);
 else
 {
 opc=op[0];
 switch(ierOp)
 { ///daca e paranteza deschisa, se introduce pe stiva
 case PD: //([{
 OPER.push(opc);
 break;
 ///daca e paranteza inchisa, se extrag toate elementele
 ///de pe stiva pana la intalnirea unei paranteze deschise
 case PI: //)]}
 while(ierarhie(OPER.top())!=PD)
 POSTFIX.adauga(OPER.pop());
 OPER.pop();
 break;
 ///daca e alt operator, se extrag elemente de pe stiva atat
 ///timp cat stiva nu este goala si ierarhia operatorului
 ///din varful stivei este mai mare sau egala decat ierahia
 ///operatorului curent
 ///la sfarsit operatorul curent se depune pe stiva
 default:

 while((!OPER.eGoala())&&ierarhie(OPER.top())>=ierOp)
 POSTFIX.adauga(OPER.pop());
 OPER.push(opc);
 break;
 }
 }
}
void evalPOSTFIX()
{
 string op;
 char opc;
 double t1, t2, rez;
 ///atat timp cat nu s-a ajuns la sfarsitul expresiei postfixate
 while(!POSTFIX.eGoala())
 {
 ///daca elementul curent este numar acesta se depune pe stiva
 while(POSTFIX.eNumar())
 EVAL.push(POSTFIX.getNumar());
 //se extrag 2 valori de pe stiva
 t2=EVAL.pop();
 t1=EVAL.pop();
 op=POSTFIX.extrage();
 opc=op[0];
 ///se efectueaza operatia dintre cele 2 valori
 switch(opc)
 {
 case '+':
 rez=t1+t2;
 break;
 case '-':
 rez=t1-t2;
 break;
 case '*':
 rez=t1*t2;
 break;
 case '/':
 rez=t1/t2;
 break;
 default:
 eroare("Operator necunoscut!", 1);
 }
 ///rezultatul operatiei se depune pe stiva
 EVAL.push(rez);
 }
}
void main(int argc, char* argv[])
{
 ///se primeste ca parametru numele fisierului in care se
 ///gaseste expresia matematica ce se doreste a fi evaluata
 string numefis;
 if(argc!=2)
 { cout<<"Specificati numele unui fisier pentru care doriti
scrierea postfixata!";
 exit(1);
 }
 numefis=argv[1];

 f.open(numefis.c_str());
 if(f.bad())
 {
 cout<<"Fisierul "<<numefis<<" nu exista.\n";
 exit(2);
 }

 cout<<"Lucrez cu fisierul "<<numefis<<".\n";

 ///parcurge fisierul primit ca parametru
 string op;
 while(!f.eof())
 {
 op=f.citeste();
 scrierePOSTFIX(op);
 }
 f.close();
 ///se extrag toti operatorii ramasi pe stiva
 while(!OPER.eGoala())
 POSTFIX.adauga(OPER.pop());
 ///afiseaza expresia din fisier in forma postfixata
 cout<<"\n\nExpresia in scriere postfixata\n";
 for(int i=0;i<POSTFIX.size();i++)
 cout<<POSTFIX[i]<<" ";
 ///efectueaza calculul expresiei
 evalPOSTFIX();
 ///afiseaza valoarea expresiei (ultima valoare ramasa pe stiva)
 cout<<"\nValoarea expresiei este: "<<EVAL.pop()<<"\n";
}
///ierarhie.h - informatii despre ierarhia operatorilor
#define PD 1
#define PI 2
#define PLUSMINUS 3
#define INMIMP 4
int ierarhie(char c)
{
 switch (c)
 {
 case '+':
 case '-':
 return PLUSMINUS;
 break;
 case '*':
 case '/':
 return INMIMP;
 break;
 case '(':
 case '[':
 case '{':
 return PD;
 break;
 case ')':
 case ']':
 case '}':
 return PI;
 break;
 default:
 return 0;
 break;
 }
};
int ierarhie(string & s)
{
 char c;
 c=s[0];
 return ierarhie(c);
};
///coada.h - Clasa coada
void eroare(const char * text,int nr);
class coada{
private:
 ///implementarea cozii cu o clasa template double ended que din
 ///C++ Standard Template Library
 deque <string> s;
public:
 ///verifica daca coada e goala
 bool eGoala()
 {
 return s.empty();
 };
 ///adauga un element in coada
 void adauga(const string & str)
 {
 s.push_back(str);
 };
 ///adauga un element in coada
 void adauga(char c)
 {
 string str;
 str=c;
 s.push_back(str);
 };
 ///intoarce si extrage primul element din coada
 string extrage()
 {
 string t;
 if(!s.empty())
 {
 t=s.front();
 s.pop_front();
 }
 else eroare("Eroare de sintaxa.",2);
 return t;
 };
 ///verifica daca primul element din coada reprezinta un numar
 bool eNumar()
 {
 char *stop;
 string st=s.front();
 strtod(st.c_str(), &stop);
 return (*stop) == 0;
 };
 ///extrage elementul din coada ca numar
 double getNumar()
 {
 char *stop;
 double v;
 string st;
 st=s.front();
 s.pop_front();
 v=strtod(st.c_str(), &stop);
 return v;
 };
 ///intoarce a i-lea element din coada (0 - primul element)
 string operator [] (unsigned int i)
 {
 if((i>=0) && (i<s.size()))
 return s[i];
 eroare("Eroare de sintaxa.",4);
 return "";
 };
 ///intoarce numarul de elemente din coada
 int size()
 {
 return s.size();
 };
};
///stiva.h - Clasa template stiva
void eroare(const char * text,int nr);
template <class T>
class stiva{
private:
 ///implementarea stivei cu o clasa template double ended que din
 ///C++ Standard Template Library
 deque <T> s;
public:
 ///verifica daca stiva e goala
 bool eGoala()
 {
 return s.empty();
 };
 ///introduce un element in stiva
 void push(T str)
 {
 s.push_back(str);
 };
 ///intoarce si extrage elementul din stiva
 T pop()
 {
 T t;
 if(!s.empty())
 {
 t=s.back();
 s.pop_back();
 }
 else eroare("Eroare de sintaxa.",5);
 return t;
 };
 ///intoarce elementul din stiva
 T top()
 {
 if (!s.empty())
 return s.back();
 eroare("Eroare de sintaxa.",6);
 return NULL;
 };
};
///fisier.h - clasa fisier
#include <string>
#include <fstream>
using namespace std;
class fisier
{
public:
 ///citeste o noua secventa de caractere din fisierul de date
 string citeste();
 ///deschide fisierul
 void open(const char * numefis);
 ///verifica daca fisierul a fost deschis cu succes
 bool bad();
 ///verifica daca s-a ajuns la sfarsitul fisierului
 bool eof();
 ///inchide fisierul deschis
 void close();
private:
 /// fisierul din care se citesc datele
 ifstream fis;
 /// verifica daca parametrul primit este separator sau operator
 bool isSeparator(string s);
 /// verifica daca parametrul primit este separator sau operator
 bool isSeparator(char c);
 ///scoate spatiile albe din datele de intrare (tab, spatiu, sfarsit
de linie)
 void eatWhite();
};
///fisier.cpp - clasa fisier
#include "fisier.h"
/// verifica daca parametrul primit este separator sau operator
bool fisier::isSeparator(string s)
{
 char c=s[0];
 return (c=='+') || (c=='-') || (c=='*') || (c=='/') || (c=='(') ||
 (c=='[') || (c=='{') || (c==')') || (c==']') || (c=='}')
||
 (c=='\n') || (c=='\t') || (c==' ');
};
// verifica daca parametrul primit este separator sau operator
bool fisier::isSeparator(char c)
{
 return (c=='+') || (c=='-') || (c=='*') || (c=='/') || (c=='(') ||
 (c=='[') || (c=='{') || (c==')') || (c==']') || (c=='}')
||
 (c=='\n') || (c=='\t') || (c==' ');
}
///scoate spatiile albe din datele de intrare (tab, spatiu, sfarsit de
linie)
void fisier::eatWhite()
{
 while((fis.peek()==' ') || (fis.peek()=='\n') ||
(fis.peek()=='\t'))
 fis.get();
}
///citeste o noua secventa de caractere din fisierul de date
string fisier::citeste()
{
 string rez="";
 rez=fis.get();
 if(!isSeparator(rez))
 while(!isSeparator(fis.peek()) && !fis.eof())
 rez+=fis.get();
 eatWhite();

 return rez;
}
///deschide fisierul
void fisier::open(const char * numefis)
{
 fis.open(numefis);
 eatWhite();
}
///verifica daca fisierul a fost deschis cu succes
bool fisier::bad()
{
 return fis.bad();
}
///verifica daca s-a ajuns la sfarsitul fisierului
bool fisier::eof()
{
 return fis.eof();
}
///inchide fisierul deschis
void fisier::close()
{
 fis.close();
}