Templates în C++

Ce sunt Templates?

Templates permit scrierea de cod generic care funcționează cu orice tip de date.

Funcții Template

Copiază
1#include <iostream>
2using namespace std;
3
4// Funcție template
5template <typename T>
6T maxim(T a, T b) {
7    return (a > b) ? a : b;
8}
9
10// Cu mai multe tipuri
11template <typename T, typename U>
12auto suma(T a, U b) -> decltype(a + b) {
13    return a + b;
14}
15
16int main() {
17    cout << maxim(3, 7) << endl;       // 7 (int)
18    cout << maxim(3.5, 2.1) << endl;   // 3.5 (double)
19    cout << maxim('a', 'z') << endl;   // z (char)
20    
21    cout << suma(3, 2.5) << endl;      // 5.5
22    
23    return 0;
24}

Clase Template

Copiază
1template <typename T>
2class Stiva {
3private:
4    T* arr;
5    int top;
6    int capacitate;
7    
8public:
9    Stiva(int cap = 100) : capacitate(cap), top(-1) {
10        arr = new T[capacitate];
11    }
12    
13    ~Stiva() {
14        delete[] arr;
15    }
16    
17    void push(const T& val) {
18        if (top < capacitate - 1)
19            arr[++top] = val;
20    }
21    
22    T pop() {
23        if (top >= 0)
24            return arr[top--];
25        throw runtime_error("Stiva goală");
26    }
27    
28    bool isEmpty() const {
29        return top == -1;
30    }
31};
32
33int main() {
34    Stiva<int> stivaInt;
35    stivaInt.push(10);
36    stivaInt.push(20);
37    cout << stivaInt.pop() << endl;  // 20
38    
39    Stiva<string> stivaStr;
40    stivaStr.push("Hello");
41    stivaStr.push("World");
42    cout << stivaStr.pop() << endl;  // World
43    
44    return 0;
45}

Template cu Valori Non-Type

Copiază
1template <typename T, int Size>
2class Array {
3private:
4    T arr[Size];
5    
6public:
7    T& operator[](int index) {
8        return arr[index];
9    }
10    
11    int size() const { return Size; }
12};
13
14int main() {
15    Array<int, 5> arr;
16    arr[0] = 10;
17    cout << arr.size() << endl;  // 5
18    
19    return 0;
20}

Specializare Template

Copiază
1// Template general
2template <typename T>
3class Container {
4public:
5    void print() {
6        cout << "Container generic" << endl;
7    }
8};
9
10// Specializare pentru bool
11template <>
12class Container<bool> {
13public:
14    void print() {
15        cout << "Container pentru bool (optimizat)" << endl;
16    }
17};

Variadic Templates (C++11)

Copiază
1// Funcție cu număr variabil de parametri
2template <typename T>
3T suma(T val) {
4    return val;
5}
6
7template <typename T, typename... Args>
8T suma(T first, Args... rest) {
9    return first + suma(rest...);
10}
11
12int main() {
13    cout << suma(1, 2, 3, 4, 5) << endl;  // 15
14    return 0;
15}

Avantaje Templates

1. •Cod reutilizabil - scrii o dată, folosești cu orice tip
2. •Type-safe - erori detectate la compilare
3. •Performanță - cod specializat generat la compilare (no runtime overhead)