C9: Functii si clase template

Cuprins:

Functii template
Clase template

Derivate de si din clase template

De da structura de clase:

class Piesa
protected: char cod[4];
int pret;

class Piesa_A
int gauri;

class Piesa_B
char * culoare;

class Ansamblu
Piesa_A pa;
Piesa_B *vec;
int pret;
Obs:
1. dimensiunea lui vec este egala
cu numarul de gauri din pa
2. pretul este dat de suma
preturilor pieselor componente

Cerinte:
1. Realizati un vector care sa contina obiecte de tip: Piesa_A, Piesa_B si Ansamblu.
2. Sortati-l dupa pret
3. Parcurgeti-l si afisati toate atributele obiectelor.
(Tineti cont de regulile de buna implementare si reutilizare a codului!)
Observatii:
1. = > clasele Piesa si Ansamblu au nevoie de o interfata comuna (avem nevoie de o clasa
Object care contine numai metode virtuale pure).
2. =>avem nevoie de o metoda getPret - o putem declara virtuala pura in Object
3. =>avem nevoie de o metoda afisare - o putem declara abstracta in Object

#include <cstdlib>
#include <iostream>
#include <string.h>
using namespace std;
class Object
{ public:
virtual void afisare()=0;
virtual int getPret()=0;
virtual ~Object(){}
};
class Piesa: public Object
{ protected: char cod[4];
int pret;
public: Piesa(){}
Piesa(char c[4],int p)
{strcpy(cod,c);
pret=p;}
void afisare()
{cout<<"Cod: "<<cod<<endl;
cout<<"Pret: "<<pret<<endl;}
int getPret(){return pret;}
};

class Piesa_A:public Piesa

{ protected: int gauri;
public:
Piesa_A(char c[4],int p,int g):Piesa(c,p),gauri(g)
{}
void afisare()
{ Piesa::afisare();
cout<<"Numar gauri: "<<gauri<<endl;
cout<<"_________"<<endl;
}

int getGauri() // am nevoie de ea in Ansamblu

{ return gauri;}//pentru dimensiunea lui vec
};
OBS: 1. Pentru Piesa si Piesa_A compilatorul va
genera constructor de copiere, destructor si
operator de atribuire, pe care ii voi putea folosi
in Ansamblu
2. Metoda getPret, a fost implementata
in clasa Piesa si se va mosteni in toate clasele
derivate din Piesa; nu trebuie sa ii schimbam
implementarea, DAR
3. functia afisare trebuie suprascrisa

class Piesa_B:public Piesa

{ protected: char *culoare;
public:
Piesa_B(){} //necesar in Ansamblu la alocarea spatiului pentru vec
Piesa_B(char c[4],int p,char *cl):Piesa(c,p)
{ culoare=new char[strlen(cl)+1];
strcpy(culoare,cl);}

Piesa_B(const Piesa_B& p):Piesa(p)

{ culoare=new char[strlen(p.culoare)+1];
strcpy(culoare,p.culoare);}

//avem atribut pointer

//il vom folosi in Ansamblu

Piesa_B& operator=(const Piesa_B&p)

//avem atribut pointer
{ Piesa::operator=(p);
//il vom folosi in Ansamblu
if (!culoare) delete []culoare;
culoare=new char[strlen(p.culoare)+1];
strcpy(culoare,p.culoare);
return *this;
}

~Piesa_B() { delete[]culoare;}
void afisare()
{ Piesa::afisare();
cout<<"Culoare: "<<culoare<<endl;
cout<<"_________"<<endl;
}
};

//avem atribut pointer

//il vom folosi in Ansamblu

class Ansamblu:public Object

//derivata din Object; compusa cu Piesa_A, Piesa_B
{ protected: Piesa_A pa;
Piesa_B *vec;
int pret;
public:
Ansamblu(Piesa_A a, Piesa_B*v):pa(a) //s-a generat automat acest constructor
{ //sau, daca nu apelam pa(a): pa=a;
vec=new Piesa_B[pa.getGauri()]; //apel constructor fara parametri din Piesa_B
pret=pa.getPret();
for(int i=0;i<pa.getGauri();i++) {
vec[i]=v[i];
pret+=vec[i].getPret();
}
}
Ansamblu& operator=(const Ansamblu &an)
{
pa=an.pa;
//operator= generat de compilator pt Piesa_A
vec=new Piesa_B[pa.getGauri()];
for(int i=0;i<pa.getGauri();i++)
vec[i]=an.vec[i];
pret=getPret();
return *this;
}

Ansamblu(const Ansamblu& an)

{
*this=an;
}
~Ansamblu()
{ delete []vec; }
void afisare()
{
pa.afisare();
for(int i=0;i<pa.getGauri();i++)
vec[i].afisare();
cout<<"Pret: "<<getPret()<<endl;
cout<<"_________"<<endl;
}

int getPret()
{ pret=pa.getPret();
for(int i=0;i<pa.getGauri();i++)
pret+=vec[i].getPret();
return pret;
}
};

Am nevoie de atributul pret?

Nu. E suficienta metoda getPret()
Tema: implementati modificarea

int main(int argc, char *argv[])

{ Piesa_A a("abc",3,2);
Piesa_B b("abc",6,"rosu");
Piesa_B *v=new Piesa_B[2];
v[0]=b; v[1]=b;
Ansamblu ceva(a,v);

Object **vec=new Object*[3];

vec[0]=&a;
vec[1]=&b;
vec[2]=&ceva;
for(i=0;i<2;i++)
for(j=i+1;j<3;j++)
if(vec[i]->getPret()>vec[j]->getPret())
{ Object *aux=vec[i];
vec[i]=vec[j];
vec[j]=aux;
//ce atribuiri se fac aici, de fapt?
}
for(i=0;i<3;i++)
vec[i]->afisare();
system("PAUSE");
return EXIT_SUCCESS;
}

C9: Functii si clase template

Functii template
template = sablon

utilizate in cazurile in care avem implementari multiple pentru o functie, iar

diferenta dintre implementari apare numai prin faptul ca folosim alte tipuri de
date (semnatura: acelasi numar de parametri, dar tipuri diferite ale acestora)

Exemplu: s-ar putea intr-o aplicatie sa avem nevoie de mai multe functii care sa
calculeze suma elementelor unor vectori; vectorii difera prin tipul de date stocate : int,
double, complex precum si prin dimensiune
int suma(int* vec,int dim)
{
int s(0);

double suma(double * vec,int dim)

{
double s(0);

for (int i=0; i<dim ;i++)

s=s+vec[i];

for (int i=0; i<dim ;i++)

s=s+vec[i];

return s;

return s;
} pentru cazul in care vectorul este de tip double
functia trebuie rescrisa (supraincarcata)

complex suma(complex * vec,int dim)

{
complex s(0);//constructor cu parametri

pentru cazul in care vectorul este de tip complex

functia trebuie rescrisa (supraincarcata)

for (int i=0; i<dim ;i++)

s=s+vec[i];// operator de atribuire si de adunare pentru tipul de date complex
return s; //constructor de copiere pentru tipul de date complex
}
class complex
{ double re,im;
public:
//automat au fost generati constructor de copiere si operator de atribuire
//ce mai trebuie implementat? Constructor care initializeaza cu 0;operator+
complex(double r=0,double i=0){ re=r; im=i;}

friend complex operator+(const complex &x,const complex &y){

return complex(x.re+y.re,x.im+y.im);
}
friend ostream& operator<<(ostream &d,complex x)
{ d<<x.re<<" j"<<x.im;
return d;
}//s-ar putea sa vrem sa afisam suma
};

Cazul este destul de des intalnit si in alte contexte

este recomandat sa se gaseasca o cale de generalizare;
generalizarea este date de template mecanism oferit de C++

template <typename T>

T sum(T* vec, int dim)
{
T s(0);
for (int i=0; i<dim ;i++)
s=s+vec[i];
return s;

Functiile template folosesc cuvantul template

pentru a preciza ca e vorba de o functie speciala si
operatorii ( < ) si ( > ) : < Continut >

Continutul poate sa fie un tip de date generic :

ex. T - specificat prin:
typename T

sau

class T

Putem sa enumeram mai multe tipuri.

Functia este parametrizata dupa tipurile de date,
nu specializata ca in cazurile precedent.

10

int main()
{
int n;
cin>>n;

OBS: Daca nu foloseam functia

template, trebuia sa rescriem
acelasi cod de mai multe ori (nu se
schimba decat tipul de date
manevrat).

int *v=new int[n];

double *v1=new double[n];
complex *v2=new complex[n]; //constructor fara parametru pentru complex
for (int i=0; i<n ;i++)
{ v[i]=i;
v1[i]=(double)i/2;
v2[i]=complex(i,i); //constructor cu parametri pentru complex
}

cout<<sum(v,n)<<endl; //apel functie template pentru tipul int; specializare int

cout<<sum(v1,n)<<endl; //apel functie template pentru tipul double; specializare double
cout << sum (v2,n)<<endl;//apel functie template pentru tipul complex; specializare complex
//folosesc operatorul de afisare pentru tipul de date complex; a fost implementat
//ce face compilatorul cand intalneste un apel de functie?
system("PAUSE");
return 1;
}

Alt exemplu :
void afis(const int& x)
{
cout <<x<<endl;
}

void afis(const double& x)

{
cout <<x<<endl;
}
void afis(const complex& x)
{
cout <<x<<endl;
}
//utilizare
int x=3;
double dd=2.00;
afis(x);
afis(dd);
afis(complex(10,10));

template <typename T>

void afis(const T& x)
{
cout <<x<<endl;
}
//utilizare
int x=3;
double dd=2.00;
afis(x);//functia template e specializata pt. int
afis(dd); //functia template e specializata pt.
//double
afis(complex(10,10)); //functia template e
//specializata pt. complex

C9: Functii si clase template

Functii template - Definitii si observatii:
Functiile sablon (template) sunt functii speciale care folosesc tipuri generice(generic types)
Functiile template sunt functii a caror functionalitate poate sa fie adaptata pentru mai
mult de un tip de date fara a rescrie functia pentru fiecare tip de date in parte parametrizare dupa tip.
C++: permite folosirea de parametri template.
Un parametru template este un tip special de parametru care poate sa fie folosit pentru a
transmite un tip de date ca argument (cum un parametru obisnuit al unei functii poate fi
folosit ca sa transmita valori in acea functie, la fel si un parametru template poate sa
transmita un tip de date intr-o functie).
Functiile template pot folosi parametrii ca si cand ar fi de tip cunoscut.
Functiile template se declara astfel:
template <class tip1, ,class tipN>
tip_de_date_returnat nume_functie(semnatura){};
sau
template <typename tip1, , typename tipN >
tip_de_date_returnat nume_functie(semnatura){};

Diferenta intre prototipuri este folosirea cuvintelor cheie: class, respectiv, typename.
Nu exista nicio deosebire intre cele doua forme.
template <class T, class U>
inline T getMin (T a, U b)
{
return (a<b?a:b);
}
//utilizare
int x=3;
double dd=3.10;
//pot preciza exact ce tipuri de date folosesc la apel
cout<<getMin<double,int>(dd,x); //functia e specializata pentru tipurile de date double
//si int
//sau, acelasi lucru:
cout<<getMin (dd,x); //functia e specializata pentru tipurile de date double si int

OBS:
La apelul unei functii template legarea se face in mod static.
Tipul unui parametru template este determinat in momentul compilarii => nu o sa putem
avea functii virtuale template.

C9: Functii si clase template

Parametrii care nu reprezinta un tip de date in functii template
In afara de argumente template (precedate de cuvantul class sau typename) care reprezinta
tipuri, functiile template pot sa aiba si parametri obisnuiti, similari cu cei folositi in functii.
template <typename T, int dim>
T sum(T* vec)
{ T s(0);
for (int i=0; i<dim ;i++)
s=s+vec[i];
return s;
}
//utilizare
int n=10;
int *v=new int[n];
double *v1=new double[n];
for (int i=0; i<n ;i++)
{ v[i]=i;
v1[i]=(double)i/2;
}
cout<<sum<int,10>(v)<<endl; //functia e specializata pentru int, iar dim este 10
cout<<sum<double,10>(v1)<<endl; //functia e specializata pentru double, iar dim este 10

C9: Functii si clase template

Tipuri generice default:
template <typename T=int, int dim=10>
T sum(T* vec)
{ T s(0);
for (int i=0; i<dim ;i++)
s=s+vec[i];
return s;
}

//apel
cout<<" suma pt. vector de tip double cu dimensiunea 5: " << sum<double,5>(v) <<endl;
cout<<" suma pt. vector de tip int cu dimensiunea 10: "<< sum<int>(v)<<endl;
cout<<" suma pt. vector de tip int cu dimensiunea 10: "<< sum<>(v)<<endl;
cout<<" suma pt. vector de tip int cu dimensiunea 10: "<< sum(v)<<endl;
OBS: Nu toate compilatoarele permit tipuri default (Dev C++).

Dati exemple de functii care pot fi facute template!

Teme
1. Realizati o functie template care interschimba valorile a doua variabile

2. Realizati o functie template pentru sortarea elementelor unui vector.

Ce trebuie implementat intr-o clasa (tip de date definit de utilizator) astfel incat ea sa
specializeze functia de sortare?

3. Implementati o functie pentru afisarea elementelor unui vector, parametrizata dupa

tipul T si dimensiunea de tip int - dim.

C9: Functii si clase template

Metode ale unei clase ca functii template
#include <iostream>
using namespace std;
class VectorInt
{
int buf[10];
public:
template<typename T>
void copie_cu_convesie(T sursa[10])
{
for(int i = 0; i<10; i++)
{ buf[i] = (int)sursa[i];
}
}

};

int main()
{
int v[10];
double v1[10];
float v2[10];
for (int i = 0; i<10; i++)
{ v[i]=i;
v1[i]=(double)i;
v2[i]=(float)i;
}
VectorInt vobj;
vobj.copie_cu_convesie(v);
vobj.copie_cu_convesie(v1);
vobj.copie_cu_convesie(v2);
system("PAUSE");
return 1;
}

C9: Functii si clase template

Clase template
Exista posibilitatea realizarii de clase template au functii membre care folosesc atribute
de tip template.
Sintaxa:
template <class tip1, ,class tipN>
class nume_clasa
{//tip1 a; //
//tipN*vec;
//metode
};
sau:

template <typename tip1, , typename tipN >

class nume_clasa
{//
};
OBS: Ca si in cazul functiilor template, se pot transmite si parametri care nu sunt tipuri de
date intre <>

#include <iostream>
using namespace std;
#include <math.h>
template <typename X, typename Y>
class pereche
{ X elem1;
Y elem2;
public:
pereche(const X &e1, const Y &e2)
{elem1=e1;
elem2=e2;
}

class complex
{ double re,im;
public:
complex(double r=0,double i=0){re=r;im=i;}
friend ostream& operator<<(ostream &d,complex x)
{ d<<x.re<<" j"<<x.im;
return d;
}
double getModul()
{ return sqrt(pow(re,2)+pow(im,2));}
};

friend ostream& operator<<(ostream &d,pereche x)

{d<<x.elem1<<" si " << x.elem2<<endl;
return d;
}
};

int main()
{ pereche<int, double> p(4,3.00);
cout<<p;
complex x(1,1);
pereche<complex,double> p1(x,x.getModul());
cout<<p1;
system("PAUSE");
return 1;
}

Trebuie sa existe:
operator=, constructor fara
param., operator<< pentru
tipurile de date cu care se face
specializarea clasei pereche

C9: Functii si clase template

Tipuri template default
template <typename X, typename Y=X>
class pereche
{ X elem1;
Y elem2;
};
//apel
Pereche<int,int> p;
sau
Pereche<int> p;
template <typename X=int, typename Y=X>
class pereche
{ X elem1;
Y elem2;
};
//apel
Pereche<int,int> p;
sau
Pereche<int> p;
Sau
Pereche<> p;

C9: Functii si clase template

Ce diferente apar daca separ headerul de implementare?
template <typename X, typename Y>
class pereche
{
X elem1;
Y elem2;
public:
pereche(const X& , const Y &);
X getElem1();
Y getElem2();
friend ostream& operator<<(ostream &d,pereche x)
{
d<<x.elem1<<" si "<<x.elem2<<endl;
return d;
}
};
//in mod normal, in clasa: friend ostream& operator<<(ostream &d,pereche);
//in exterior:
//template <typename X, typename Y>
//ostream& operator<<(ostream &d,pereche<X,Y>p){}

template <typename X, typename Y>

pereche<X,Y>::pereche(const X &e1,
const Y &e2)
{
elem1=e1;
elem2=e2;
}
template <typename X, typename Y>
X pereche<X,Y>::getElem1()
{
return elem1;
}
template <typename X, typename Y>
Y pereche<X,Y>::getElem2()
{
return elem2;
}

int main()
{
pereche<int, double> p(4,3.00);
cout<<p.getElem1()<< ;
cout<<p.getElem2()<<endl;
cout<<p;
system("PAUSE");
return 1;
}

Metodele clasei sunt template.

Templateuri si separarea header-interfata

Din punct de vedere al compilatorului, clasele si functiile template nu sunt functii si clase
obisnuite.
Ele sunt compilate la cerere, adica codul nu e compilat pana la instantierea cu
argumente specifice.
In acel moment, compilatorul genereaza o functie specifica pentru acele argumente ale
functiei template.
Cand dimensiunea proiectului creste, codul este de obicei impartit in mai multe fisiere
sursa si header pentru a separa interfetele de implementari.
Deoarece clasele/functiile template sunt compilate la cerere, apare restrictia ca
implementarea si declaratia unei functii trebuie sa fie facuta in acelasi fisier.
Deci trebuie ca interfata si implementarea sa fie facute in acelasi loc.
(OBS: unele compilatoare permit separarea)
Deoarece codul se genereaza in momentul instantierii, compilatorul e pregatit sa permita
includerea multipla a unei clase template fara erori de linkage.
Atentie! In Dev C++ s-ar putea sa aveti probleme inclusiv daca nu am clasa template in
acelasi fisier cu functia main(); respectiv, functiile friend nu sunt implementate in clasa;
depinde de versiune.

C9: Functii si clase template

Clasele template sunt foarte utile pentru dezvoltarea de clase de tip container/colectie:
vectori, liste, stive, cozi, multimi, etc
friend ostream & operator << (ostream & dev,
//Vector template
vector & v)
#include <iostream>
{
using namespace std;
dev << "Vector:" <<endl;
//as putea parametriza si dupa dim
dev << "Nr Elem:" << v.dim << endl;
template <typename T>
for(int i = 0; i < v.dim; i++)
class vector
{
{ int dim;
dev << v.buf[i];//operator<< pt T
T* buf;
dev << endl;
public:
}
vector(int , T*);
return dev;
vector(const vector&);
}
~vector();
vector & operator=(const vector &);
};
T& operator[](int i);
int getDim();
// void afisare(); -de implementat
//void addElem(int i) - cu realocare
//void removeElem(int i) - cu realocare tema
//implementati orice alte metode care vi se par utile

template <typename T>

vector<T>::vector(int d, T*b)
{ dim=d;
buf=new T[dim];
for (int i=0;i<dim;i++)
buf[i]=b[i];
}

//functie membra template parametrizata dupa T

//face parte din clasa template vector<T>
//constructor fara parametri pt. T
//operator=pt. T

template <typename T>

vector<T>::vector(const vector<T>& v) //parametrul functiei este de tipul vector
//parametrizat dupa T
{ dim=v.dim;
buf=new T[dim];
for (int i=0;i<dim;i++)
buf[i]=v.buf[i];
}

template <typename T>

vector<T>::~vector()
{
delete [] buf;
}

//destructor pt. T

template <typename T>

vector<T>& vector<T>::operator=(const vector<T> &v){
dim=v.dim;
if (!buf) delete [] buf;
//tipul T necesita destructor
buf=new T[dim];
//tipul T necesita constructor fara parametri
for (int i=0;i<dim;i++)
buf[i]=v.buf[i];
//tipul T necesita operator=
return *this;
}

template <typename T>

T& vector<T>::operator[](int i) //returnez un obiect de tipul elementelor stocate in vector: T
{
return buf[i];
//tipul T necesita constructor de copiere
}

template <typename T>

int vector<T>::getDim(){return dim;}

//pentru a specializa clasa vector vom folosi tipurile: complex si punct si clasele derivate
class complex
{ double re,im;
public: complex(double =0,double =0);
friend ostream& operator<<(ostream &,complex );
}; //s-au generat automat operator=, constructor de copiere si destructor

class Punct
{ protected: double x,y;
public:
Punct(){}
Punct(double i,double j):x(i),y(j){}
friend ostream& operator<<(ostream &d,Punct * p) //va functiona doar pentru pointeri
{ p->afisare(d);
return d; }
friend ostream& operator<<(ostream &d, Punct & p)
{ p.afisare(d);
return d; }
virtual void afisare(ostream &d){
d<<"Perimetrul: "<<perimetrul()<<endl; d<<"Aria: "<<aria()<<endl; }
virtual double perimetrul()=0;
virtual double aria()=0;
virtual ~Punct(){}
}; //automat s-au generat operator=, constructor de copiere si destructor

class Cerc:public Punct

{ protected: double R;
static const double pi=3.14;
public:
Cerc(double i,double j,double raza):Punct(i,j),R(raza){}
void afisare(ostream &d){ d<<"Raza:"<<R<<endl;
Punct::afisare(d);
}
double perimetrul(){return 2*pi*R;}
double aria(){return pi*R*R;}
};
class Dreptunghi:public Punct
{ private: double lung;
protected: double lat;
public:
Dreptunghi(){}
Dreptunghi(double i,double j,double l1,double l2):Punct(i,j),lung(l1),lat(l2){}
void afisare(ostream &d){
d<<"Laturile:"<<lung<<", "<<lat<<endl;
Punct::afisare(d);
}
double perimetrul(){return 2*(lung+lat);}
double aria(){return lung*lat;}
};

int main()
{
int n;
cin>>n;
int *v=new int[n];
double *v1=new double[n];
complex *v2=new complex[n];
for (int i=0; i<n ;i++)
{ v[i]=i;
v1[i]=(double)i/2;
v2[i]=complex(i,i);
}
vector<int> vti(n,v);
cout<<vti<<endl;
vector<double> vtid(n,v1);
for (int i=0; i<vtid.getDim() ;i++)
cout<<vtid[i]<<" "<<endl;
vector<complex> vtic(n,v2);
cout<<vtic<<endl;

//vtic=vtid;
//no match for 'operator=' in 'vtic = vtid'
//candidates are: vector<T>&
//vector<T>::operator=(const vector<T>&)
//[with T = complex]
vector<complex> cv(vtic);
vtic=cv;
cout<<vtic;

Punct**vpc=new Punct*[2];
vpc[0]=new Cerc(0,0,3);
vpc[1]=new Dreptunghi(4,4,4,4);
vector<Punct*> vp(2,vpc);
cout<<vp;//acesta e motivul pentru care a
//trebuit implementat in ierarhia derivata
//din Punct operator<<
//Puteam face altfel?
system("PAUSE");return 1;
}

C9: Functii si clase template

Derivarea din /de clase template
Voi prezenta decat modele de derivare simpla (dar este permis orice tip de derivare:
eg. din mai multe clase de baza template, publica, private, protected sau virtuala).
1. O clasa obisnuita derivata dintr-o clasa template
2. O clasa template derivata dintr-o clasa obisnuita de baza
3. O clasa template derivata din alta clasa template
OBS: O clasa template este un sablon pentru o clasa, ea va fi instantiata in functie de
tipurile de date si argumentele pe care le foloseste.
O instantiere conduce la specializarea acelei clase.
Procesul se numeste instantiere, iar rezulatul se numeste specializare.
Cand derivam trebuie sa ne punem problema ce urmeaza sa mostenim in clasa
derivata:
o clasa template : Ceva_ce_foloseste<T>
sau specializarea ei : Ceva_ce_foloseste<int>

* clasa obisnuita - derivata dintr-o specializare a unei clase template

#include <iostream>
using namespace std;
template <typename T>
class Baza{
protected:
T a1;
public:
Baza(T i){a1=i; }
void afis() {cout<<a1;}
T geta1(){return a1;}
};
class Der: public Baza<int>
{
int atr2;
public:
Der(int i, int j):Baza<int>(i),atr2(j){}
void afis() {
cout<<a1;
cout<<atr2;}
};

int main()
{
Der d(2,2); //Der nu e template
d.afis();
system("PAUSE");
return 1;
}

* clasa obisnuita derivata dintr-o clasa template nespecializata

#include <iostream>
using namespace std;
template <typename T>
class Baza{
protected:
T a1;
public:
Baza(T i){a1=i; }
void afis() {cout<<a1;}
T geta1(){return a1;}
};
template <typename T>
class Der: public Baza<T>
{
int atr2;
public:
Der(T i, int j):Baza<T>(i),atr2(j){}
void afis() {
cout<<Baza<T>::a1;
cout<<atr2;}
};

int main()
{
Der<int> d(2,2);
d.afis();
system("PAUSE");
return 1;
}

* clasa template derivata dintr-o clasa obisnuita de baza

#include <iostream>
using namespace std;
class Baza{
protected: int a1;
public:
Baza(int i){a1=i; }
void afis() {cout<<a1;}
int geta1(){return a1;}
};
template <typename T>
class Der : public Baza{
T a2;
public:

Der(int i, T j):Baza(i),a2(j){}
void afis() {
cout<<a1;
cout<<a2;
}
};

int main()
{
Der<int> d(2,2);//Der specializata pt int
d.afis();
system("PAUSE");
return 1;
}

* clasa template derivata dintr-o alta clasa template

#include <iostream>
using namespace std;
template <typename T>
class Baza{
protected: T a1;
public:
Baza(T i){a1=i; }
void afis() {cout<<a1;}
T geta1(){return a1;}

};
template <typename T1,typename T>
class Der : public Baza<T>{
T1 a2;
public:
Der(T i, T1 j):Baza<T>(i),a2(j){}
void afis() {
cout<<Baza<T>::a1;
cout<<a2;
}
};

int main()
{
Der<int,int> d(2,2);
//Der e specializata pentru int si int
d.afis();
system("PAUSE");
return 1;
}

//Stiva mimata ca functionalitate - FIFO

#include <iostream>
using namespace std;
#include <assert.h>
template <typename T>
class stack {
T *p;
//un vector in care stochez elementele
int nrmax; // capacitate maxima
int nrcrt; // cate elemente am/unde ma aflu in vectorul p
int sp;
// varful stivei
public: stack(int = 15);
~stack();
stack(const stack &);
void push(const T&); //adaug element in varf
T pop(void);
//scot element din varf
int empty(void);
//e stiva goala?
int full (void);
//e stiva plina?
stack & operator= (const stack &);
friend ostream& operator<<(ostream& dev, stack&s){
for (int i=0; i < s.nrcrt; i++)
dev << s.p[i] << " ";
dev << "\n";
return dev;};
};

template <typename T>

stack<T>::stack(int n) //constructor cu parametru capacitatea stivei
{
p = new T[n];
nrmax = n; nrcrt = 0; sp = -1;
}

template <typename T>

stack<T>::stack(const stack <T> & s)
{
p = new T[s.nrmax];
nrmax = s.nrmax;
nrcrt = s.nrcrt;
sp = s.sp;
for (int i = 0; i < nrcrt; i++)
p[i] = s.p[i];
}
template <typename T>
stack<T>::~stack()
{
delete [] p;
}

//constructor de copiere

template <typename T>

void stack<T>::push(const T& el)
{
assert(nrcrt < nrmax);
p[++sp] = el;
nrcrt++;
}
//implementati functia cu facilitatea de a
//creste dimensiunea stivei in caz de
//depasire
template <typename T>
T stack<T>::pop(void)
{
assert(nrcrt > 0);
nrcrt--;
return p[sp--];
}
template <typename T>
int stack<T>::full(void)
{
return (nrcrt == nrmax);
}

template <typename T>

int stack<T>::empty(void)
{
return (nrcrt == 0);
}
template <typename T>
stack<T> & stack<T>::operator=(const
stack <T> & s)
{
assert(p != NULL);
delete [] p;
p=new T[nrmax = s.nrmax];
nrcrt = s.nrcrt;
sp = s.sp;
for (int i = 0; i < nrcrt; i++)
p[i] = s.p[i];
return *this;
}

typedef stack<int> STI; //tip de date STI: stiva specializata pentru int
int main(void)
{
stack<int> si;
//stiva specializata pentru int sau : STI si;
stack<char > ss; //stiva specializata pentru char
int a[3] = { 1, 2, 3,};
char s[3] = { 1, 2, 3};
for(int i = 0; i < 3; i++) {
si.push(a[i]); //populez stivele cu elemente
ss.push(s[i]);
}
stack<int> sj(si);
stack<char> st;
st = ss;

//creez cu constructorul de copiere stiva sj

//atribuiri intre stive specializate pentru acelasi tip de date

i = 0;
while (!sj.empty()) a[i++] = sj.pop(); //scot elementele din stiva si le pun in vector
i = 0;
while (!st.empty()) s[i++] = st.pop(); //scot elementele din stiva si le pun in vector
for(i = 0; i < 3; i++) cout << a[i] << " "; cout << "\n";
for(i = 0; i < 3; i++) cout << "\"" << s[i] << "\" ";
//ce se afiseaza?

cout << "\n";

sj.push(21); sj.push(22); //pun elemente in stive

stack<STI> ssi;
//creez o stiva de stive de int
ssi.push (si); ssi.push(sj); //adaug doua stive de int in ssi
cout << "si: " << si;
cout << "sj: " << sj;
cout << "Stiva de stive: ";
cout << ssi << "\n";

//afisam stiva in ordine inversa

si = ssi.pop();
cout << "si: " << si;
sj = ssi.pop();
cout << "sj: " << sj;
system("PAUSE");
return 1;
}

// Se va apela operatorul << pentru

// elementele componente

Probleme:
1.Implementati clasa Poligon cu capacitati minime: constructori, operator=,
destructor, metoda de afisare, metoda calcul lungime (2 puncte consecutive ),
metoda de calcul a centrului.
Un poligon e descris de un vector de puncte.
Integrati clasa Poligon in ierarhia de figuri geometrice.

2. Considerati problema prezentata la inceputul cursului cu modificarea ca

Ansamblu contine doi vectori de piese de tip necunoscut (poate contine vectori de
Piesa, Piesa_A sau Piesa_B) iar vectorii nu au inca dimensiunea cunoscuta.
Cum ati implementa aceasta clasa?
3. Folosind clasa Vector si Pereche realizati o clasa Dictionar cu facilitatea de cautare
a unui cuvant si afisarea definitiei pentru acesta precum si de sortare a cuvintelor
explicate.
4. Implementati sub forma de clasa template - clasa stack, vezi C3 (nu doar mimand
comportamentul de stiva).
5. Implementati clasa Matrice template; cu supradefinirea operatorilor de *,+,etc.
Specializati clasa pentru tipurile de date complex, int double, etc