Intrări ieşiri standard

Supraîncarcarea << >>

Partea a II-a
Intro
 Pe nivelul cel mai de jos, un fişier este interpretat ca un flux
de octeţi (stream). Pe nivelul utilizator, fişierul constă dintr-o
secventă de date de tipuri diferite: caractere, numerice,
obiecte.

 Biblioteca de functii de intrare-iesire realizeazaă interfaţa

dintre cele două niveluri. Conceptul fundamental pentru
constructia bibliotecii de intrare-iesire este cel de stream,
vazut ca un flux de date de la o anumita sursa la o anumita
destinatie.
 Biblioteca standard C++ contine clase care
reprezinta diferite tipuri de fluxuri (stream-uri).
Fiecare flux poate fi de intrare, de iesire, sau mixt de
intrare/iesire.
 Operaţia fundamentală pentru fluxul de iesire este
inserarea de date, iar pentru cel de iesire este
extragerea de date.
 Fisierul header iostream.h contine declaraţiile
fluxului de intrare (clasa istream), ale fluxului de
ieşire (clasa ostream), precum si declaratiile
obiectelor cin (intrare consolă) si cout (ieşire
consolă).
 Operatiile de inserare si extragere sunt realizate prin funcţii
membre ale claselor ostream si istream. Deoarece limbajul C++
permite existenta funcţiilor prin care sunt supraîncarcaţi
operatorii predefiniti, prin convenţie, inserarea se face prin
supraincarcarea operatorului de deplasare la stânga <<, iar
extragerea prin supraincarcarea celui de deplasare la dreapta
>>.
 In clasa ostream, operatorul << este supradefinit sub forma:
ostream& operator << (tipPredefinit);
 In clasa istream, operatorul >> este supradefinit sub forma:
istream& operator >> (tipPredefinit);
 Operatorii de inserare (<<) si extragere (>>) sunt
supraîncarcaţi astfel incat operandul drept să poata
fi de orice tip predefinit.
 Programatorul poate supraîncarca în continuare
aceşti operatori pentru propriile tipuri introduse prin
clase. (ca funcţii globale friend)
istream& operator>> (istream&, NumeClasa &);
ostream& operator<< (ostream&, NumeClasa);
Supraincarcarea operatorilor << şi>>
pentru clasa NrComplex
#include <iostream.h>
class NrComplex {
float re, im;
public:
NrComplex(float r=0, float i=0)
{ re=r; im=i; }
friend istream& operator >> (istream&, NrComplex&);
friend ostream& operator << (ostream&, NrComplex);
};

istream& operator >> (istream& in, NrComplex& c)

{ in>> c.re>> c.im;
return in;
}
Supraincarcarea operatorilor << şi>>
pentru clasa Complex
ostream& operator << (ostream& out, NrComplex c)
{
//out << "Re=" << c.re << " Im=" << c.im; //sau
out<<c.re<<"+"<<c.im<<"i";
return out;
}
void main()
{
NrComplex z;
cin>>z;
cout<<z;
}
Şabloane- template
Definiţie
 caracteristică a limbajului de programare C++
(nu si Java)
 permit scrierea de cod fără a lua în
considerare tipul concret de dată ce va fi
utilizat ulterior

 Șabloanele permit programare generică în C++.

Clase generice

 Clasele template sunt clase generice (a nu se confunda

cu noţiunea de clasă abstractă)
 conţin atribute de un tip oarecare de date, tip de date care nu se
cunoaşte decît la momentul instanţierii obiectelor.

 Aceste clase devin utile în cazul în care operăm cu

obiecte ale căror atribute pot fi de mai multe tipuri, spre
exemplu: vectori de numere întregi, vectori de numere
reale, vectori de caractere.
Clase generice
 Definirea claselor template se face respectând sintaxa
următoare:

template < class NumeOarecare >

class NumeClasa
{
…
Numeoarecare atribut;
…
} //sfarsit clasa
Clase generice
 Exemplu

template <class TipElem>

class Triplet
{
TipElem a1;
TipElem a2;
TipElem a3;
...};
Clase generice
 Definirea metodelor unei clase template se
face în manierea următoare:

template < class NumeOarecare >

Tip NumeClasa<NumeOarecare>::NumeMetoda (parametri)
{…
};
Clase generice
 Exemplu:

template <class TipElem>

int Triplet<TipElem>::NumaraElemente()
{
return 3;
};
Clase generice
 Antetul definirii unei clase template poate conţine pe lîngă
construcţia <class NumeOarecare> şi parametri:

template <class NumeOarecare, Tip1 par1 , Tip2 par2, …>

 Exemplu:
template <class TipElem, int dimensiune>
Clase generice
 Instanţierea unor obiecte ale claselor template
se face prin construcţia:
NumeClasa < TipDeDateConcret> obiect;
 Exemplu:
Triplet <int> obiect;//triplet de intregi
Triplet <TPersoana> obiect;
Cod sursa –ex1
template <class ceva, int lg> int main()
class vector { {printf("\n vector intregi:");
ceva v[lg]; vector<int,4> vi;
public: vi.cit();vi.tip();
vector(){}; printf("\n vector reale:");
void tip();void cit(); vector<float,4> vf;
ceva best();} vf.cit();vf.tip();
printf("\n vector caractere:");
template <class ceva, int lg>
vector<char,4> vc;
void vector<ceva,lg>::tip()
vc.cit();vc.tip();
{ for(int i=1;i<=lg;i++)
cout<<"\t"<<v[i]; } return 0;
}
Ex1: Să se construiască clasa şablon
template <class ceva, int lg> vector pentru care se vor putea
void vector<ceva,lg>::cit() { instanţia obiecte cu semnificaţia:
for(int i=1;i<=lg;i++) cin>>v[i]; } şir de numere întregi, şir de
numere reale sau şir de caractere.
Cod sursa –ex2
#include <iostream.h>
class Complex{ template <class Numar>
double Re; class vector{
double Im; Numar *vect;
public: int dim;
Complex(){}; public: vector(){dim=0;vect=0;}
Complex(double a, double b){Re=a;Im=b;} vector(int l);
//supraincarcarea operatorilor >> şi << void tip(); };//sf clasa generica
friend istream& //definirea constructorului
operator>>(istream&,Complex&); template <class Numar>
friend vector<Numar>::vector(int l)
ostream&operator<<(ostream&,Complex); { dim=l;
};//class Complex vect=new Numar[dim];
istream& operator>>(istream& intrare, Complex &z) for(int i=1;i<=dim;i++)
{ cin>>vect[i];
cout<<"\nRe:";cin>>z.Re; }
cout<<"\nIm:";cin>>z.Im; //definirea metodei de afisare
return intrare; template <class Numar>
}//sf operator>> void vector<Numar>::tip()
ostream& operator<<(ostream& iesire, Complex z) {for(int i=1;i<=dim;i++)
{ cout<<"\t"<<vect[i];
cout<<z.Re<<"+i"<<z.Im; }
return iesire; void main()
} {vector<double> vd(4);
vd.tip();
vector<Complex> vc(4);
vc.tip();}