Problema I

n Să se realizeze o funcție care să calculeze

Funcții și Clase maximul dintr-un șir de elemente
Template ¨ elementele sunt numere întregi
¨ elementele sunt numere reale
¨. . .
Mihai Gabroveanu

Funcții și Clase Template 2

Funcții Identice

Soluție Diferă tipul unor parametri

Funcții și Clase Template
int max(int n, int t[]){ float max(int n, float t[]){
int m=t[0];
for(int i=1;i<n;i++){
float m=t[0];
for(int i=1;i<n;i++){
n Un template (şablon) defineşte o familie de
if(t[i]>m)
m=t[i];
if(t[i]>m)
m=t[i]; funcţii, respectiv de clase generice
} }
return m; return m; (parametrizate) utilizând tipurile ca parametri
} }
n Reprezintă o altă tehnică de reutilizarea a
int main(){ codului.
int a[3]={2,1,9};
float b[4]={3.0,1.2,4.8,1.9};
cout<<max(3,a)<<endl;;
cout<<max(4,b);
}

Funcții și Clase Template 3 Funcții și Clase Template 4

Funcții Template
n O funcție template (şablon, generică) este un tipar utilizat de
compilator pentru a construi automat diverse funcţii.
n Se utilizează pentru implementarea de funcţii care diferă doar
prin tipul parametrilor
n Sintaxă:
template <par1, par2,..., parn>
antet_funcţie_parametrizată;
unde:
par1, par2,..., parn sunt parametrii funcției template, de regulă constante
sau tipuri de date specificate prin cuvântul cheie class sau typename.
Parametrii din lista parametrilor şablonului (template) trebuie să apară
toţi în lista de parametri formali ai funcţiei template
Apelul Funcților Template
n Sintaxa apelului unei funcții template:
nume_funcţie_parametrizata(expr1, expr2,...,exprn)
unde expr1, expr2,...,exprn sunt expresii din care
se deduc tipurile concrete
sau
nume_funcţie_parametrizata<tipC1,tipC2,…, tipCn>(lista_parametrii)
unde tipC1, tipC2,...,tipCn sunt tipuri concrete sau
constante utilizate pentru a genera versiunea
corespunzătoare de funcție

Funcții și Clase Template 5 Funcții și Clase Template 6

Generarea Funcțiilor Template Exemplu: Soluție II

template <typename T>
T max(int n, T t[]){
n Generarea de cod pentru entitatea template T m=t[0];
for(int i=1;i<n;i++){
are loc la compilare. if(t[i]>m)
m=t[i];
n La apelul funcţiei parametrizate, tipul
}
return m;
argumentelor determină care versiune a }

şablonului este folosită. int main(){

int a[3]={2,1,9};
float b[4]={3.0,1.2,4.8,1.9};
cout<<max<int>(3,a)<<endl;
cout<<max<float>(4,b)<<endl;
cout<<max(3,a)<<endl; //tipul este dedus din tipul elementelor lui a
getch();
}

Funcții și Clase Template 7 Funcții și Clase Template 8

Problema II Soluție
class Vector { } else {
private: throw out_of_range("Depasire limite");
n Să se implementeze o clasă ce float elem[MAX];
int n; }
}

public:
implementează noțiunea de Vector cu Vector(int n);
int getNrElemente() const;
void Vector::print(){
int i;

elemente numere reale.

float& operator[] (int i); for (i = 0; i < n; i++){
void print(); cout << elem[i]<<" ";
}; }
Vector::Vector(int n){ cout<<endl;
this->n = n; }
if(n>MAX)
throw out_of_range("Depasire dimensiune int main() {
maxima"); Vector v(5);
} for(int i = 0; i < v.getNrElemente(); i++) {
int Vector::getNrElemente() const { v[i] = i/2.0;
return n; }
} v.print();
float& Vector::operator[] (int i) { getch();
if (i >= 0 && i < n){ return 0;
return elem[i]; }

Ce se întâmplă dacă dorim un tablou cu numere întregi sau cărțile dintr-o bibliotecă?
Funcții și Clase Template 9 Funcții și Clase Template 10

Clase Template Instanțierea Claselor Template

n O clasă template (generică) este un model (un n Sintaxa instanțierii unei clase template:
şablon) utilizat pentru generarea unor clase
concrete, clase ce diferă prin tipul anumitor date nume_clasă <tipC1,tipC2,…, tipCn> nume_obiect(lista_param_constructor);
membre. unde tipC1, tipC2,...,tipCn sunt tipuri
n Sintaxă: concrete sau constante utilizate pentru a
template < par1, par2,..., parn > declarare_clasă; genera versiunea corespunzătoare de clasă
par1, par2,..., parn sunt parametrii clasei template, de
regulă constante sau tipuri de date specificate prin
cuvântul cheie class sau typename.

Funcții și Clase Template 11 Funcții și Clase Template 12

 Exemplu Exemplu (cont.)
template <class T> template <class T>
class Vector { int Vector<T>::getNrElemente() const {
private: return n; int main() {
T elem[MAX]; } Vector<int> vi(5);
int n; template <class T> for(int i = 0; i < vi.getNrElemente(); i++) {
T& Vector<T>:: operator[] (int i) { vi[i] = i * i;
public: if (i >= 0 && i < n){
Vector(int n); return elem[i];
}
int getNrElemente() const; } else { vi.print();
T& operator[] (int i); throw out_of_range("Depasire limite"); Vector<float> vf(5);
void print(); } for(int i = 0; i < vf.getNrElemente(); i++) {
}; } vf[i] = i/2.0;
template <class T>
template <class T> void Vector<T>::print(){
}
Vector<T>::Vector (int n){ int i; vf.print();
this->n = n; for (i = 0; i < n; i++){ getch();
if(n>MAX) cout << elem[i]<<" "; return 0;
throw out_of_range("Depasire dimensiune }
}
maxima"); cout<<endl;
} }

Funcții și Clase Template 13 Funcții și Clase Template 14

Exemplu (cont.) Derivarea claselor parametrizate

class Carte{
private:
ostream& operator<<(ostream& out, const Carte&c){
out<<"Titlu:"<<c.titlu<<endl;
n O clasă parametrizată se poate moștenii, caz
în care clasa derivată va fi tot o clasă
char titlu[100]; out<<"Autor:"<<c.autor<<endl;
char autor[100]; return out;
public: }
Carte(char *titlu="", char *autor=""){
strcpy(this->titlu, titlu);
int main() {
Vector<Carte> v(2); parametrizată cu aceiaşi parametri, la care
strcpy(this->autor, autor); v[0]=Carte("Limbajul C+", "L. Negrescu");
}
friend ostream& operator << (ostream& out,
v[1]=Carte("Limbajul C++", "I. Muslea");
v.print();
eventual de pot adăuga alţii noi.
const Carte& c); getch();
}; return 0;
}

Funcții și Clase Template 15 Funcții și Clase Template 16

Exemplu Temă
#include <iostream> template <typename T, typename C >
class CD: public CB < T > { n Să se implementeze o funcţie template care să sorteze
using namespace std; C c;
public: CD(T t, C c): CB < T > (t) elementele unui vector.
template < typename T > {
class CB {
T t; }
this - > c = c; n Implementati clasa Multime care să poată reţine elemente de
public:
CB(T t) {
void print() {
CB < T > ::print();
orice tip. Să se supraîncarce operatorii +, * pentru a realiza
}
this - > t = t;
}
cout << c; reuniunea respectiv intersecţia a două mulțimi.
void print() {
cout << t;
};
n Implementaţi clasa generică Lista care să poată reţine
};
} int main() {
CD < int, double > ob(1, 6.5);
elemente de orice tip. Să se supraîncarce operatorul []
ob.print();
getch();
pentru a accesul la elementul i.
}
n Implementați clasa generică (template) care să
implementeze un arbore binar.

Funcții și Clase Template 17 Funcții și Clase Template 18