Template in C++: funzioni e classi generiche spiegate

Scrivilo una volta, usalo con ogni tipo

Nella pagina precedente hai ordinato un vector<int> con std::sort. Ma std::sort ordina anche un vector<string>, un vector<double> o un array delle tue struct, senza che nessuno abbia scritto un sort separato per ognuno. Non è magia e non è overloading. È un template: un unico pezzo di codice che il compilatore riutilizza per qualunque tipo gli passi.

Senza template dovresti copiare e incollare la stessa logica per ogni tipo. Ecco la stessa funzione maximum scritta tre volte, che è esattamente la duplicazione che i template esistono per eliminare:

int    maximum(int a, int b)       { return a > b ? a : b; }
double maximum(double a, double b) { return a > b ? a : b; }
string maximum(string a, string b) { return a > b ? a : b; }

I corpi sono identici. Cambiano solo i tipi. Un template ti permette di dire "questo funziona per qualsiasi tipo T" e di scriverlo una volta sola.

Template di funzione

Trasformi una funzione in un template aggiungendo template <typename T> davanti e usando T dove normalmente andrebbe un tipo concreto.

#include <iostream>
#include <string>
using namespace std;

template <typename T>
T maximum(T a, T b) {
    return a > b ? a : b;
}

int main() {
    cout << maximum(3, 7) << "\n";          // 7   (T = int)
    cout << maximum(2.5, 1.1) << "\n";      // 2.5 (T = double)
    cout << maximum(string("apple"),
                    string("banana")) << "\n"; // banana (T = string)
    return 0;
}

Nota che non hai mai scritto maximum<int> o maximum<double>. Il compilatore guarda gli argomenti e capisce quale deve essere T: questa è la deduzione degli argomenti del template. Ogni tipo diverso con cui la chiami fa sì che il compilatore istanzi (generi) dietro le quinte una funzione concreta separata.

Puoi anche indicare il tipo in modo esplicito quando la deduzione non aiuta, usando le parentesi angolari:

#include <iostream>
using namespace std;

template <typename T>
T zero() {            // niente da cui dedurre: nessun argomento
    return T{};
}

int main() {
    cout << zero<int>() << "\n";     // 0
    cout << zero<double>() << "\n";  // 0
    return 0;
}

Nella deduzione si nasconde un'insidia comune. Dato che T deve essere un unico tipo, mescolare tipi di argomento diversi la manda in crisi:

maximum(3, 7.5);   // ERRORE: T è int o double? Il compilatore si rifiuta di indovinare.

Puoi risolvere essendo espliciti, maximum<double>(3, 7.5), oppure dando a ogni parametro il suo parametro di tipo, come faremo adesso.

Più parametri di tipo

Un template non è limitato a un solo tipo. Elencane quanti ne servono, separati da virgole. Così scrivi una funzione i cui parametri possono essere di tipi diversi:

#include <iostream>
#include <string>
using namespace std;

template <typename A, typename B>
void printPair(A first, B second) {
    cout << first << " -> " << second << "\n";
}

int main() {
    printPair(1, "one");        // A = int, B = const char*
    printPair(3.14, true);      // A = double, B = bool
    printPair("pi", 3.14159);   // A = const char*, B = double
    return 0;
}

Quando il tipo di ritorno dipende dai parametri, lascia che sia il compilatore a calcolarlo con auto (da C++14 in poi), che si abbina in modo naturale ai template:

#include <iostream>
using namespace std;

template <typename A, typename B>
auto add(A a, B b) {
    return a + b;   // tipo di ritorno dedotto da a + b
}

int main() {
    cout << add(2, 3) << "\n";     // 5    (int + int)
    cout << add(2, 3.5) << "\n";   // 5.5  (int + double -> double)
    return 0;
}

Template di classe

I template non sono solo per le funzioni: anche intere classi possono essere template. È esattamente così che funzionano i contenitori standard: vector<int>, la map chiave-valore e pair<A, B> sono tutti template di classe. Scrivi la struttura dati una volta sola e questa memorizza qualunque tipo tu le passi come parametro.

Ecco un piccolo Box generico che contiene un valore di qualsiasi tipo:

#include <iostream>
#include <string>
using namespace std;

template <typename T>
class Box {
    T value;
public:
    Box(T v) : value(v) {}
    T get() const { return value; }
    void set(T v) { value = v; }
};

int main() {
    Box<int> intBox(42);
    Box<string> wordBox("hello");

    cout << intBox.get() << "\n";   // 42
    cout << wordBox.get() << "\n";  // hello

    intBox.set(100);
    cout << intBox.get() << "\n";   // 100
    return 0;
}

La differenza principale rispetto ai template di funzione: con un template di classe di solito devi indicare il tipo tra parentesi angolari, Box<int>, perché negli standard più vecchi non ci sono argomenti del costruttore da cui dedurlo. (C++17 ha aggiunto la deduzione degli argomenti dei template di classe, quindi funziona anche Box b(42);, ma essere espliciti è sempre sicuro e si legge meglio.)

Gli errori saranno enormi: ecco perché

Questa è la parte che mette in difficoltà tutti, quindi vale la pena dirla chiaramente. Un template viene controllato del tutto solo quando è istanziato con un tipo reale. Puoi scrivere un template che usa < e compilarlo senza problemi: l'errore compare solo nel momento in cui lo istanzi con un tipo che non ha <.

template <typename T>
T maximum(T a, T b) {
    return a > b ? a : b;   // richiede che T supporti >
}

struct Point { int x, y; };

// maximum(Point{1,2}, Point{3,4});
// ERRORE: nessun operator > per Point. Il messaggio nomina Point E
// cita tutta questa funzione, spesso su molte righe.

Poiché il compilatore sostituisce il tipo completo nel template e segnala i fallimenti dall'interno del codice generato, un singolo errore può produrre un muro di output che cita i dettagli interni della libreria. Due consigli per sopravvivere:

• Leggi il primo errore, non l'ultimo. Quelli successivi di solito sono conseguenze del primo.
• Cerca nel messaggio il nome del tuo tipo (qui, Point). Ti dice quale istanziazione è andata storta.

La vera soluzione è assicurarsi che il tuo tipo supporti tutto ciò che serve al template: per maximum, significa fare l'overloading di operator> per Point, un argomento per una pagina successiva. I concept del C++20 moderno possono anticipare questi errori e renderli leggibili, ma il modello di sostituzione sottostante è lo stesso.

Prossimo: classi

Hai appena costruito un template di classe Box, una classe con dati privati, un costruttore e funzioni membro, concentrandoti però sui template. La prossima pagina rallenta e spiega le classi come si deve: come riunire i dati con le funzioni che ci lavorano, cosa controllano davvero public e private e come le funzioni membro accedono allo stato dell'oggetto. Template e classi si combinano di continuo nel C++ reale, quindi una buona padronanza delle classi rende il codice generico molto più facile da scrivere.