Plantillas (Templates)

Es una manera especial de escribir funciones y clases para que estas puedan ser usadas con cualquier tipo de datos. Según va aumentando la complejidad de nuestro programa y sobre todo, de los problemas a los que nos enfrentamos, descubrimos que tenemos que repetir una y otra vez la misma estructura, es aquí que las plantillas nos ayudan evitando el trabajo de escribir cada versión de función.

Las plantillas es no definir un tipo de dato desde el principio, si no dejar esto como algo pendiente y usar algo que permita manejar varias opciones. Para declarar una plantilla seguimos las siguiente reglas template <typename identifier> function_definition o template <class identifier> function_definition , la palabra reservada template indica al compilador que estamos haciendo uso de una plantilla de función.

#include <cstdio>
#include <iostream>

using namespace std;

char maxOfChar(char a, char b) {
    return (a > b ? a : b);
}

int maxOfInt(int a, int b) {
    return (a > b ? a : b);
}

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

int main()
{
    char i = maxOfChar('e', 'z');
    int j = maxOfInt(9, 4);

    cout << "Max character between e and z is: " << i << endl;
    cout << "Max integer between 9 and 4 is: " << j << endl;

    char x = maxOf<char>('e', 'z');
    int y = maxOf<int>(9, 4);

    cout << "Max character between e and z using template is: " << x << endl;
    cout << "Max integer between 9 and 4 using template is: " << y << endl;

    return 0;
}
//-> Max character between e and z is: z
//-> Max integer between 9 and 4 is: 9
//-> Max character between e and z using template is: z
//-> Max integer between 9 and 4 using template is: 9

En el caso del uso de class

template <class T> T maxOf(T a, T b) {
    return (a > b ? a : b);
}

Clases-plantilla

También podemos escribir clases con plantillas, llamadas clases-plantill y crear objetos que sirvan con cualquier tipo de dato, estas características es de gran ayuda al momento de escribir por ejemplo arreglos o matrices que sirven con cualquier tipo y no solo con uno. Las reglas para las clases-plantillas son la siguiente:

template <class identifier> class_definition;

template <class identifier> 
return_type name_class<identifier>::name_function(argument){
    // Implemantation
}

Ahora el ejemplo.

#include <cstdio>
#include <iostream>

using namespace std;

template <class T>
class Coordinate {
    private:
        T x;
        T y;

    public:
        Coordinate(T x = 0, T y = 0);

        T getX() {
            return x;
        };

        T getY() {
            return y;
        }

        void setX(T x) {
            this->x = x;
        }

        void setY(T y) {
            this->y = y;
        }
};

template <class T>
Coordinate<T>::Coordinate(T x, T y) {
    this->x = x;
    this->y = y;
}

int main()
{
    Coordinate <int> coord1(2,1);
    Coordinate <float> coord2(1.5, 0.5);

    cout << "First coordinate of X is: " << coord1.getX() << endl;
    cout << "Second coordinate  of Y is: " << coord2.getY() << endl; 

    return 0;
}
//-> First coordinate of X is: 2
//-> Second coordinate  of Y is: 0.5

Gracias a las clases-plantilla es posible lograr un estilo de programación genérico, como es el caso de la biblioteca estándar de plantillas STL (Standard Template Library) de C++ que utiliza las plantillas para crear y proporcionar una gran colección de herramientas como lo son los contenedores (vector es uno de los más conocidos) y algoritmos (como los de ordenamiento y de búsqueda) que trabajan sobre estas estructuras de datos.