11.

STIVE I COZI
11.1 Consideraii privind structurilor de date de tip stiv i
coad
O stiv, stack n limba englez, este o structur de tip LIFO (Last In First
Out =ultimul intrat primul ieit) i este un caz particular al listei liniare n care
toate inserrile (depunerile n englez push) i tergerile (sau extragerile -n
englez pop) (n general orice acces) sunt fcute la unul din capetele listei,
numit vrful stivei. Acest nod poate fi citit, poate fi ters sau n faa lui se
poate insera un nou nod care devine cap de stiv.

push

pop

Figura 11.1 Mecanismul de stiv

Pentru nelegerea mecanismului unei stive, se poate folosi
reprezentarea manevrrii ntr-un depou a vagoanelor de cale ferat sau a unui
vraf de farfurii din care putem depune i extrage doar n i din vrful vrafului.
Stivele sunt legate i de algoritmii recursivi, la care salvarea variabilelor dintr-o
funcie care se apeleaz recursiv se face avnd la baz un mecanism de tip
stiv.
O stiv poate fi implementat ca o list liniar pentru care operaiile de
acces (inserare, tergere, accesare element) sunt restricionate astfel:
inserarea se face doar n faa primului element al listei, capul listei;
accesarea respectiv tergerea acioneaz doar asupra primului
element al listei.
O stiv poate fi implementat folosind o structur de date static sau
dinamic.

n abordarea static, stiva poate fi organizat pe un spaiu de memorare

de tip tablou unidimensional.
n abordarea dinamic, implementarea unei stive se poate face folosind
o structur de tip list liniar simplu nlnuit n care inserarea se va face tot
timpul n capul listei iar tergerea de asemenea se va face n capul listei.
O coad (n englez queue) este o structur de tip FIFO (First In First
Out = Primul venit primul servit), n care toate inserrile se fac la un capt al
ei (numit capul cozii) iar tergerile (extragerile) (n general orice acces) se fac
la cellalt capt (numit sfritul cozii). n cazul cozii, avem nevoie de doi
pointeri, unul ctre primul element al cozii (capul cozii), iar altul ctre ultimul
su element (sfritul cozii). Exist i o variant de coad circular, n care
elementele sunt legate n cerc, iar cei doi pointeri, indicnd capul i sfritul
cozii, sunt undeva pe acest cerc.

push

pop

Figura 11.2 Mecanismul de coad

Se face o analogie cu o cale ferat pe un singur sens sau cu obinuita
coad la un ghieu oarecare la care primul venit este i primul servit.
Pentru gestiunea unei cozi sunt necesari doi indicatori:
- un indicator care indic primul element ce urmeaz a fi scos;
- un indicator care indic unde va fi pus urmtorul element adugat la
coad.
ntr-o abordare static, o coad poate fi implementat folosind un spaiu
de memorare de tip tablou unidimensional. n acest caz, adugri i tergeri
repetate n coad deplaseaz coninutul cozii la dreapta, fa de nceputul
vectorului. Pentru evitarea acestei deplasri, o soluie este ca fiecare operaie
de extragere din coad s fie acompaniat de deplasarea la stnga a
coninutului cozii cu o poziie. n acest caz, primul element care urmeaz s fie
eliminat din coad va fi ntotdeauna pe prima poziie, indicatorul care s indice
elementul ce urmeaz s fie scos pierzndu-i utilitatea. Dezavantajul acestei
soluii l reprezint necesitatea deplasrii ntregului set de elemente din coad
rmase cu o poziie.
ntr-o abordare dinamic, o coad poate fi implementat folosind o list
liniar simplu nlnuit la care operaiile de acces sunt restricionate
corespunztor. Exist dou abordri:
-una n care adugarea se face tot timpul la nceputul listei liniare simplu
nlnuite iar extragerea se face de la sfritul listei
-cea de a doua, n care adugarea se face la sfritul listei iar extragerea se
face din capul listei.
Pentru implementarea unei cozi, vom folosi aspectele tratate n capitolul
de liste liniare.

11.2 Caracteristicile structurilor de date de tip stiv

Caracteristicile unei stive sunt puse n eviden prin comparaie cu
structura de date de tip list:
- n timp ce pentru gestionarea listei se vehiculeaz cu variabile de tip
Tp, care stocheaz adresa componentei (Z1, 1) a listei, componenta
numit cap de list, n cazul stivei este memorat adresa ultimei
componente (Z'n, 'n), numit vrful stivei;
- n timp ce cont cont(n) = NULL n cazul listei, cont ('1) = NULL n
cazul stivei;
- n timp ce succ (Zj) = Zj+1 n cazul listei, n cazul stivei succ(Zj)=Zj-1;
- n timp ce pred (Zj) = Zj-1 n cazul listei, n cazul stivei
pred(Zj)=Zj+1;
- n tip ce parcurgerea n cazul listei este de la (Z1, 1) spre (Zn, m), n
cazul stivei, parcurgerea este de la (Z'n, 'n) spre ( Z'1, '1 );
- n timp ce disciplina lucrului cu elementele listei este primul venit
primul servit (FIFO), n cazul stivei regula de vehiculare a
elementelor, este ultimul venit primul servit (LIFO).
Se observ c stiva este o list invers. Totui, multe dintre tehnicile de
rezolvare a problemelor vehiculeaz stive i nu liste, datorit disciplinei de
gestionare a elementelor.
Regulile de creare i accesare la nivel de stiv, prevd c fiecrui
element care se adaug, i se aloc o zon de memorie i acest element devine
vrf al stivei.
Exist procese n care informaiile se stocheaz n ordinea opus
momentului prelucrrii, iar odat folosit, aceasta devine necesar. Stocnd
informaiile ntr-o stiv, dup utilizarea informaiilor coninute n vrful stivei,
zona de memorie alocat este eliberat (dealocat), vrful stivei mutndu-se
cu o component spre baza stivei.
Baza stivei este considerat elementul (Z'1, '1). n funcie de cerinele de
prelucrare, se obine o fluctuaie a poziiei vrfului stivei, ceea ce creeaz o
imagine mai bun pentru dinamica prelucrrii datelor. Astfel, stivele stau la
baza gestionrii adreselor parametrilor ce se transmit n funcii, implementrii
mecanismelor de recursivitate din limbaje de programare.
n general, ideea de stiv sugereaz prelucrri care au un caracter
simetric. De exemplu, se consider o prelucrare complet privind:
A. ncrcarea componentelor C1 pentru disponibilizarea de resurse ale
unui sistem de calcul;
B. ncrcarea componentei C2 care este destinat lansrii n execuie a
programului utilizatorului;
C. efectuarea deschiderii de fiiere n programul utilizatorului C3;
D. prelucrri de date i afiri de rezultate C4;
E. nchiderea fiierelor;
F. ieirea din programul utilizatorului sub supravegherea componentei
C3;
G. ieirea din lucru sub componenta C2;

H. dezactivarea resurselor sistemului de calcul prin componenta C1.

Se construiete stiva din figura 11.3.
vrf de stiv

adr (C4)

adr (C3)

(Z'4, '4)

(Z'3, '3)

adr (C2)

(Z'2, '2)

adr (C1)

(Z'1, '1)

NULL

baza activ

Figura 11.3 Structura unei stive

Dup parcurgerea pasului D, vrfului stivei coboar la (Z'3, '3) i
componenta (Z'4, '4) este dealocat, deci distrus.
Folosind informaiile stocate n pasul C, se efectueaz tergerea fiierelor
(pasul E). Vrful stivei se coboar la componenta (Z'2, '2), iar componenta
(Z'3, '3) este eliberat.
vrf de stiv

b
a
NULL

baza activ

Figura 11.4 Structura unei stive pentru inversarea caracterelor unui ir

Se execut pasul F, care este simetricul pasului C i apoi vrful coboar
spre (Z'1, '1) i se activeaz componentele C1 pentru eliberarea resurselor pas
simetric pasului A.

Astfel, de exemplu, dac dorim s inversm poziia elementelor unui ir {a, b,

c, d, e}, prin crearea unei stive care s conin aceste elemente, cu modelul
grafic din figura 11.4 i prin apelarea unei funcii de parcurgere cu imprimarea
elementelor identificate, se obine exact irul { e, d, c, b, a }.
n cazul calculrii lui n!, se folosete formula de recuren:
P(n) = P(n-1) * n

(11.1)

cu P(1) = 1, se creeaz o stiv care conine expresiile ce sunt evaluate cu

valorile descresctoare ale lui n.
Se construiete stiva care are n informaia util, de la baz spre vrf: n,
n 1, n 2, , 3, 2, 1.
Valoarea iniial a funciei recursive P(1) = 1, permite prin parcurgerea
stivei de la vrf spre baz, obinerea rnd pe rnd a rezultatelor: P(2),
P(3),,P(n 2), P(n 1 ), P(n) i ntlnindu-se NULL la baza stivei, procesul se
ncheie.

11.3 Operaii de baz cu stive

tergerea unei stive, revine la dealocarea componentelor care formeaz
stiva. Se realizeaz prin parcurgerea integral a stivei, cu dealocarea fiecrui
vrf.
Adugarea unui element n stiv, se face de regul cu mutarea poziiei
vrfului stivei pe componenta adugat.
tergerea unui element din stiv, se efectueaz de regul asupra
elementului din vrful stivei, aceasta cobornd pe componenta ce l precede.
Parcurgerea stivei, se efectueaz de la vrf ctre baz.
Operaiile de inserare, de concatenare, de sortare a stivelor, nu difer
mult de aceleai operaii din interiorul unei liste, dar frecvena lor de utilizare
este mult mai redus.
Programul urmtor, exemplific unele dintre operaiile care se execut
cu structuri de date de tip stiv.
#include <iostream.h>
#include <malloc.h>
class elementstiva
{
public:
int info;
elementstiva *prec;
elementstiva()
{
prec=NULL;
}
};
class stiva
{

public:
elementstiva *vs; //varful stivei
stiva()
{
vs=NULL;
}
void sterg()
{
elementstiva* aux=vs;
if(vs == NULL) cout<<"\n Stiva este vida!";
else
{
aux = vs->prec;
free(vs);
while(aux !=NULL)
{
vs=aux;
aux=aux->prec;
delete vs;
}
vs = NULL;
}
}//
void tipar()
{
elementstiva* aux;
if(vs == NULL) cout<<"\n Stiva este vida!";
else
{
aux = vs;
while(aux !=NULL)
{
cout<<aux->info;
aux=aux->prec;
}
}
}
void inserare(int el)
{
elementstiva *aux;
aux = new elementstiva();
aux->info = el;
aux->prec = vs;
vs = aux;
}//
int extrag()
{
elementstiva* aux;
int el;
if (vs == NULL) return -1;
else

{
aux = vs->prec;
el = vs->info;
delete vs;
vs = aux;
return el;
}
}
};
void main()
{
stiva st;
char opt;
int x,el;
do
{
cout<<"\n Optiuni de lucru cu stiva ";
cout<<"\n P - Tiparire stiva";
cout<<"\n A - Adaugare element n stiva";
cout<<"\n E - Extragere element din stiva";
cout<<"\n T - Terminare lucru";
cin>>opt;
switch(opt)
{
case 'a':
cout<<"element:";cin>>el;
st.inserare(el);
break;
case 'e':
{
x = st.extrag();
if (x==-1)
cout<<"\n Stiva este vida!";
else
cout<<"\n Element extras"<<x;
}
break;
case 's':
st.sterg();
break;
case 'p':
st.tipar();
break;
default:
cout<<"\n Nu exista optiunea!";
}
}while (opt!='t');
}

Pe baza meniului afiat prin program, se activeaz funciile n orice

ordine, iar situaia de stiv vid, este marcat n mod corespunztor. Crearea
stivei se realizeaz prin adugri succesive, care presupun alocri dinamice de

memorie pentru elementele componente. Procedura de tergere elibereaz

toat zona de memorie alocat stivei, iar funcia de extragere, elibereaz zona
de memorie ocupat de vrful stivei i iniializeaz cu adresa noului vrf al
stivei, variabila VS.

11.4 Evaluarea expresiilor matematice cu ajutorul stivei i

cozii
Pentru evaluarea expresiilor matematice exist diferii algoritmi. Unul
dintre acetia folosete ca structur principal de date stiva.
Acest algoritm presupune rearanjarea expresiei ntr-o anumit form
astfel nct ordinea operaiilor s fie clar i evaluarea s necesite o singur
parcurgere a expresiei. Pentru aceasta se poate folosi forma polonez,
inventat de matematicianul de origine polonez Jan Lukasiewicz. Acesta
presupune scrierea operatorilor naintea operanzilor. Aceast form mai are o
variant numit scrierea polonez invers n care operatorii sunt scrii n urma
operanzilor.
Tabelul nr. 11.1 Forme ale scrierii unei expresii matematice
Expresia n forma
polonez (scriere
prefixat)

Expresia n forma
polonez invers
(scriere
postfixat)

4 + 5

+ 4 5

4 5 +

4 + 5 * 5

+ 4 * 5 5

4 5 5 * +

4 * 2 + 3

+ * 4 2 3

4 2 * 3 +

4 + 2 + 3

+ + 4 2 3

4 2 + 3 +

4 * (2 + 3)

* 4 + 2 3

4 2 3 + *

Expresia
matematic
(scriere infixat)

Dup cum se vede din tabelul 11.1, ordinea operanzilor nu se schimb,

ei gsindu-se n aceeai ordine ca n expresia matematic.
Forma polonez invers are avantaje fa de scrierea prefixat sau
infixat:
- ordinea n care se efectueaz operaiile este clar;
- parantezele nu mai sunt necesare;
- evalurile sunt uor de efectuat cu ajutorul calculatorului.
Un algoritm de transformare din expresie matematic n scriere
postfixat a fost dezvoltat de ctre Edsger Dijkstra (algoritmul macazului al lui
Dijkstra Dijkstra Shunting Algorithm). Acest algoritm utilizeaz o stiv n care
sunt pstrai operatorii i din care sunt eliminai i transferai n scrierea
postfixat. Fiecare operator are atribuit o ierarhie dup cum este prezentat n
tabelul 11.2.

Tabelul nr. 11.2 Ierarhia operatorilor

Operator

Ierarhie

( [ {

) ] }

+ -

* /

Algoritmul este:
se iniializeaz stiva i scrierea postfixat;
att timp ct nu s-a ajuns la sfritul expresiei matematice:
- se citete urmtorul element din expresie;
- dac este valoare se adaug n scrierea postfixat;
- dac este ( se introduce n stiv;
- dac este ) se transfer elemente din stiv n scrierea postfixat
pn la (;
- altfel:

att timp ct ierarhia operatorului din vrful stivei este mai

mare ierarhia operatorului curent, se trece elementul din
vrful stivei n scrierea postfixat;

se introduce operatorul curent n stiv.

se trec toi operatorii rmai pe stiv n scrierea postfixat.
Avnd expresia sub aceast form, se face evaluarea ei. Algoritmul de
evaluare folosete tot o stiv pe care sunt pstrai de aceast dat operanzii.
Algoritmul este:
se iniializeaz stiva;
att timp ct nu s-a ajuns la sfritul scrierii postfixate:
- se citete urmtorul element;
- dac este valoare se depune pe stiv;
- altfel (este operator):
se extrage din stiv elementul y;
se extrage din stiv elementul x;
se efectueaz operaia x operator y;
se depune rezultatul pe stiv;
ultima valoare care se afl pe stiv este rezultatul expresiei.
De exemplu, pentru expresia n scriere postfixat: 4 8 2 3 * - 2 / +,
algoritmul se execut ca n figura 11.5:

Elem entul citit

Stiv a

8
4

2
8
4

3
2
8
4

6
8
4

2
4

2
2
4

1
4

Figura 11.5 Execuia algoritmului

Programul care realizeaz evaluarea expresiilor matematice prin
algoritmii prezentai a fost realizat folosind programarea orientat pe obiecte.
Astfel exist o clas numit stiva care are rolul de a implementa operaiile cu
stiva necesare att la generarea expresiei n scriere postfixat ct i la
evaluarea expresiei scris n aceast form. Acest obiect are la baz clasa
deque (double ended que coad cu 2 capete list dublu nlnuit) care se
gsete n biblioteca standard de C++. Fiind nevoie de dou tipuri de stiv
(una care pstreaz operanzi i una care pstreaz valori reale) s-a construit o
clas stiv template.
Pentru pstrarea formei poloneze inverse se utilizeaz o structur de
date numit coad care este implementat tot printr-un obiect care are la baz
clasa deque.
n cadrul acestei clase sunt implementate funcii care ajut la
programarea algoritmului. Exist funcii care verific dac primul element din
coad reprezint o valoare (eNumar()), extrag primul element ca valoare
(getNumar()).
Mai exist o clas fisier care are rolul de a parcurge fiierul n care se
afl expresie aritmetic ce trebuie evaluat.
Codul surs al programului este:

#pragma warning(disable:4786)
#include <deque>
#include <iostream>
#include <string>
using namespace std;
#include
#include
#include
#include

"ierarhie.h"
"stiva.h"
"fisier.h"
"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
scrierea postfixata!";
exit(1);
}

numele

unui

fisier

pentru

care

doriti

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
break;
case '(':
case '[':
case '{':
return
break;
case ')':
case ']':
case '}':
return
break;
default:
return
break;

INMIMP;

PD;

PI;

0;

}
};
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();
}