1

Cuprins:
Introducere. Definitii. Exemple.
Clase Template derivate
Exemple (multiple)
C7: Functii si clase Template
2
C7: Functii si clase Template
1. Introducere. Definitii. Exemple:
Template = sablon
clase - incapsulare
- polimorfism !!!
- mostenire
utilizate in cazurile in care o singura implementare nu este practica pentru
diferite tipuri (cazuri) de (date) utilizari ale functiei respective
int sumVector (int *V, unsigned n)
{
int sum = 0;
for(int i = 0; i < n; i++)
sum += V[i];
return sum;
}
Exemplu:
3
C7: Functii si clase Template
pentru cazul in care vectorul este de tip double functia trebuie rescrisa
(supraincarcata)
double sumVector (double *V, unsigned n)
{
double sum = 0.0;
for(int i = 0; i < n; i++)
sum += V[i];
return sum;
}
Exemplu:
cazul este destul de des intalnit;
este recomandat sa se gaseasca o cale de generalizare;
generalizarea este date de template mecanism oferit de C++
4
C7: Functii si clase Template
Exemplu (reteta de constructie):
template <class T>
T sumVector (T *V, unsigned n)
{
T sum = 0;
// sau mai corect
// T sum(0); - este mai corect de ce?
for(int i = 0; i < n; i++)
sum += V[i];
return sum;
}
Explicatii (suplimentare):
template <class T>
face diferenta intre declaratia unei functii normale si una template;
linia apare separat de celelalte linii ale codului de definire al functiei;
< > lista de parametri;
T nume formal, eventual T1, T2, sau Type.
5
C7: Functii si clase Template
template <class T, unsigned size>
T sumVector (T (&V) [size])
{
T sum(0); // este mai corect
for(int i = 0; i < size; i++)
sum += V[i];
return sum;
}
Exemplu (alta varianta):
pot exista mai multe tipuri de date template sau non-template.
template <class T1, class T2, unsigned size1, unsigned size2>
T1 f1(T1(&V1) [size1], T2(&V1) [size2])
{
T1 rez(0);
T1 sum1(0);
T2 sum2(0);
for(int i = 0; i < size1; i++)
sum1 += V1[i];
for(int i = 0; i < size2; i++)
sum2 += V2[i];
rez = sum1 * sum2; // atentie la atribuire si inmultire
return rez;
}
6
C7: Functii si clase Template
in locul cuvantului class se poate folosi typename
template <class T>
void func (T par)
{
.
}
// este echivalent cu
template <typename T>
void func (T par)
{
.
}
cand este obligatoriu de folosi typename ???: ->
7
C7: Functii si clase Template
template <class T>
void f()
{
unsigned p;
.
{
T::m *p; // NU este luat ca produs intre T::m si p
}
}
// varianta corecta (asa DA)
template <class T>
void f()
{
unsigned p;
.
{
typename T::m *p;
}
}
8
C7: Functii si clase Template
Exemplu (apelul functiei Template - instantierea):
#include sumVector.h
int main()
{
int X[] = {1, 2};
double Y[] = {1.1, 2.2};
cout<<sumVector(X, 2)<<endl; // cu int
cout<<sumVector(Y, 2)<<endl; // cu double
return (0);
}
utilitatea claselor template este dovedita in cazul listelor, stivelor, vectorilor
(declarate a fi de tipul generic T);
ca alternativa trebuia sa definim - stiva de int
- stiva de float
- vector de double
- vector de string, etc.
ofera posibilitatea definiri o singura data a acestor tipuri de date complexe;
necesita, totusi, o parametrizare atent aleasa.
9
C7: Functii si clase Template
Exemplu (apelul functiei Template - instantierea):
vector <int> x(100);
vector <float> y(10);
parametrul <int>, <float> etc. poate fi un tip de baza sau de alt tip, eventual o structura;
Formule standard (reteta sau regula):
template <class T>
se scrie in fata clasei (inaintea cuvantului class) si inaintea oricarei definitii de metoda
care apartine clase;
vector <T>
tipul obiectului formula se scrie la definirea metodelor clasei;
10
C7: Functii si clase Template
template <class T>
class vector
{
T *p;
int dim;
public:
vector (int = 10); // constructor
vector (vector &); // constructor de copiere
~vector();
vector & operator =(vector&);
int getdim (){ return dim};
// eventual
// int set_elm(int, T);
T& operator [] (int);
};
Exemplu (mai mare):
11
C7: Functii si clase Template
template <class T> vector<T> ::vector(int d = 10)
{
p = new T[d];
assert (p != NULL);
dim = d;
}
template <class T> vector<T> ::vector(vector <T> &dreapta)
{
T *p = new T[dreapta.dim];
dim = dreapta.dim;
for(int i = 0; i < dim; i ++)
p[i] = dreapta.p[i]; // T trebuie sa stie ce inseamna = pentru
// siguranta trebuie supradefinit operatorul =
}
12
C7: Functii si clase Template
template <class T> vector<T>& vector<T> ::operator=(vector <T> &dreapta)
{
// vector <int> x(100);
// vector <int> y(200);
// x = y; // merge fara probleme
// x.operator=(y);
// ! s-ar putea scrie si x = x; !!! si ar trebui sa functioneze
if(this != &dreapta)
{
delete []p;
dim = dreapta.dim;
p = new T[dim];
for(int i = 0; i < dim; i ++)
p[i] = dreapta.p[i];
}
return *this;
}
template <class T> vector<T>::~vector ()
{
delete []p;
}
13
C7: Functii si clase Template
template <class T> T& vector<T>::operator [] (int i)
{
return (this->p)[i]; // corect
// return p[i]; // corect
}
//Aplicatie (utilizare):
typedef vector <int> VI;
void main (void) {
vector <int> iv;
vector <char> cv;
int a[10] = {1,2,3,4,5,6,7,8,9,10};
char *s[10] = {1,2,3,4,5,6,7,8,9,10};
for(int i = 0; i < 10; i ++) {
iv. set_elm(i, a[i]);
cv. set_elm(i, s[i]);
}
vector <int> ivcop(iv);
vector <char*> cvcop;
cvcop = cv;
vector <VI> vvi;
vvi.set_elm(0, iv);
vvi. set_elm(1, ivcop);
//.
}
14
C7: Functii si clase Template
15
C7: Functii si clase Template
Exemplu (pentru afisare):
template <class T>
class vector
{
T *p;
int dim;
public:
friend ostream & operator <<(ostream &div, vector &);
}
template <class T> ostream & ::operator << (ostream &div, vector <T> &v)
{
for(int i = 0; i < v.dim; i ++)
div<<v.p[i];
dev<<\n;
return (this->p)[i]; // corect
// return p[i]; // corect
}
// !!! atentie la ex:
cout<<vvi; // de cate ori este apelata functia?
16
C7: Functii si clase Template
2. Clase Template derivate:
template <class T>
class Base
{
private:
T &t;
public:
Base (T &t);
//.
}
template <class T>
class Deriv:public Base<T>
{
public:
Deriv (T &t):Base(t);
//.
}
Exemplu:
17
C7: Functii si clase Template
template <class T>
class Obi:public Base<int>
{
public:
Obi (int x):Base(x);
//.
}