What are templates and how to use them in C++

Templating in C++ is a mechanism that allows writing generic code, that is, code that can work with different types of data without having to rewrite it for each one.

Instead of defining a specific function or class for a data type (for example, int, double, string, etc.), we define a generic version that works for different types.

Templating does not imply a loss of efficiency, as the work of templating occurs during compilation, not during execution.

The compiler generates specific code for each type that you use with the template (this process is called template instantiation), generating customized versions of the code for the types needed.

Function Templates

Function templates allow you to define generic functions that can work with different types of data.

The basic syntax of a function template is:

template <typename T>
T genericFunction(T a, T b) {
    // Function code
}

Let’s see it with an example.

#include <iostream>

template <typename T>
T sum(T a, T b) {
    return a + b;
}

int main() {
    std::cout << "Sum integers: " << sum(3, 4) << std::endl;
    std::cout << "Sum floats: " << sum(3.5, 4.5) << std::endl;
    return 0;
}

Class Templates

In addition to functions, it is also possible to use class templates, which allow us to define generic classes that can handle different types of data.

The basic syntax of a class template is very similar,

template <typename T>
class GenericClass {
private:
    T data;
public:
    GenericClass(T data) : data(data) {}
    T getData() { return data; }
};

Let’s see it with an example,

#include <iostream>

template <typename T>
class Box {
private:
    T content;
public:
    Box(T content) : content(content) {}
    T getContent() { return content; }
};

int main() {
    Box<int> intBox(123);
    Box<std::string> stringBox("Hello, C++");

    std::cout << "Content of intBox: " << intBox.getContent() << std::endl;
    std::cout << "Content of stringBox: " << stringBox.getContent() << std::endl;

    return 0;
}

Multiple Parameter Template

It is also possible to define templates that accept more than one type parameter.

template <typename T, typename U>
class Pair {
private:
    T first;
    U second;
public:
    Pair(T first, U second) : first(first), second(second) {}
    T getFirst() { return first; }
    U getSecond() { return second; }
};

int main() {
    Pair<int, std::string> pair(1, "One");
    std::cout << "First: " << pair.getFirst() << ", Second: " << pair.getSecond() << std::endl;
    return 0;
}

Template Specialization

Template specialization allows defining specific implementations for certain data types.

#include <iostream>

template <typename T>
class Printer {
public:
    void print(T data) {
        std::cout << "Data: " << data << std::endl;
    }
};

// Specialization for type char*
template <>
class Printer<char*> {
public:
    void print(char* data) {
        std::cout << "String: " << data << std::endl;
    }
};

int main() {
    Printer<int> intPrinter;
    intPrinter.print(42);

    Printer<char*> stringPrinter;
    stringPrinter.print("Hello, specialization!");

    return 0;
}

Template Type Deduction

Template type deduction is the process by which the C++ compiler automatically determines the type of template parameters based on the arguments we pass.

template <typename T>
T sum(T a, T b) {
    return a + b;
}

int main() {
    int x = 5, y = 10;
    double p = 2.5, q = 3.5;

    // The compiler automatically deduces the type of T
    std::cout << sum(x, y) << std::endl;   // Deduced: T = int
    std::cout << sum(p, q) << std::endl;   // Deduced: T = double
}

Deduction Guides

Since C++17, we can also “help” the compiler deduce types for class templates using deduction guides.

template <typename T>
class Box {
public:
    T content;
    Box(T c) : content(c) {}
};

// Deduction guide
Box(const char*) -> Box<std::string>;

int main() {
    Box c1(42);          // Deduced: T = int
    Box c2("Hello");      // Deduced: T = std::string (thanks to the deduction guide)
}