20.

Şabloane

O caracteristică relativ nouă în C++ este şablonul (template). Cu un şablon este posibil să creaţi
funcţii generice. Într-o funcţie sau clasă generică, tipul de date asupra căruia operează acestea
este specificat ca un parametru. De aceea, puteţi folosi o funcţie sau o clasă cu mai multe tipuri
de date diferite, fără să rescrieţi versiunile specifice acestora.

Funcţii generice

O funcţie generică defineşte un set general de operaţii care vor fi aplicate unor tipuri de date
variate. Unei astfel de funcţii tipul de date asupra căruia va opera îi este transmis ca parametru.
Utilizând acest mecanism, poate fi aplicată aceeaşi procedură unui domeniu larg de date. Creând
o funcţie generică, puteţi defini natura algoritmului, independent de date. O dată făcut acest
lucru, atunci când se execută funcţia, compilatorul generează automat codul corect pentru tipul
de date folosit efectiv. În esenţă, când creaţi o funcţie generică, creaţi o funcţie care se
supraîncarcă singură, automat.
O astfel de funcţie este creată cu ajutorul cuvântului cheie template.

template <class Tip> tip-retur nume-functie(lista parametri)

{
//corpul functiei
}

Tip este un nume care ţine locul tipului de date folosite de către funcţie. Dar, el ţine doar un loc
pe care compilatorul îl va înlocui automat cu tipul de date efectiv, atunci când va crea o versiune
specifică a funcţiei.

#include<iostream.h>

template <class X> void inlocuieste(X &a, X &b)

{
X temp;

temp = a;
a = b;
b = temp;
}

main() {
int i = 10, j = 20;
float x = 10.1, y = 20.1;
char a = 'x', b = 'z';

inlocuieste(i, j);
inlocuieste(x, y);
inlocuieste(a, b);
cout<<i<<" "<<j<<endl; //output: 20 10
cout<<x<<" "<<y<<endl; //output: 20.1 10.1
cout<<a<<" "<<b<<endl; //output: z x
}
O funcţie cu două clase generice

#include<iostream.h>

template <class tip1, class tip2>

void function(tip1 x, tip2 y)
{
cout<<x<<" "<<y<<endl;
}

main() {
function(10, "hi");
function(0.23, 12L);
function('c', " ");

return 0;
}

Supraîncărcarea explicită a unei funcţii generice

Chiar dacă o funcţie şablon se supraîncarcă singură când este necesar, puteţi să o supraîncărcaţi
şi explicit. Dacă supraîncărcaţi o funcţie generică, atunci ea suprascrie (sau “ascunde”) funcţia
generică relativ la acea versiune specifică.

#include<iostream.h>

template <class X> void inloc(X &a, X &b)

{
X temp;
temp = a;
a = b;
b = temp;
}

//aceasta surpascrie versiunea genrica a inloc()

void inloc(int &a, int &b) {
int temp;

temp = a;
a = b;
b = temp;
cout<<" in functia inloc(int &, int &) suprascrisa.\n";
}

main() {
char 'a', 'b';
int 1, 2;

inloc('a', 'b');
inloc(1, 2); //aplarea lui inloc() supraincarcat explicit

return 0;
}