Plantillas de funciones

Parte de la sección Programación Orientada a Objetos del Journey de C++ de Coddy — lección 64 de 104.

Imagina escribir una función para encontrar el máximo de dos enteros, y luego darte cuenta de que necesitas la misma lógica para doubles, y de nuevo para strings. Sin las plantillas, escribirías funciones casi idénticas para cada tipo. Las plantillas de funciones resuelven esto permitiéndote escribir la lógica una vez y haciendo que el compilador genere versiones específicas para cada tipo automáticamente.

Una plantilla de función utiliza la palabra clave template seguida de parámetros de plantilla entre paréntesis angulares:

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

int main() {
    std::cout << maximum(5, 3) << std::endl;       // Usa la versión int
    std::cout << maximum(3.14, 2.71) << std::endl; // Usa la versión double
    std::cout << maximum('a', 'z') << std::endl;   // Usa la versión char
}

El compilador examina cada llamada y genera una función concreta para ese tipo específico. Este proceso se llama instanciación de plantilla. También puedes especificar explícitamente el tipo cuando sea necesario:

std::cout << maximum<double>(5, 3.14) << std::endl;  // Fuerza la versión double

Las plantillas pueden tener múltiples parámetros de tipo, lo que permite diseños aún más flexibles:

template <typename T, typename U>
void printPair(T first, U second) {
    std::cout << first << ", " << second << std::endl;
}

printPair(42, "hello");    // T=int, U=const char*
printPair(3.14, 100);      // T=double, U=int

Las plantillas de funciones proporcionan polimorfismo en tiempo de compilación: el tipo se determina cuando se compila el código, no en tiempo de ejecución. Esto significa una sobrecarga nula en tiempo de ejecución en comparación con las funciones virtuales, lo que hace que las plantillas sean ideales para código genérico donde el rendimiento es crítico.

Desafío

Fácil

Vamos a construir un conjunto de herramientas de utilidad utilizando plantillas de funciones para crear operaciones reutilizables que funcionen con cualquier tipo compatible. Organizarás tus funciones genéricas en un archivo de cabecera y demostrarás su flexibilidad en tu programa principal.

Crearás dos archivos:

MathUtils.h: Define una colección de plantillas de funciones que realizan operaciones comunes:
minimum — una función de plantilla que toma dos valores del mismo tipo y devuelve el más pequeño.
clamp — una función de plantilla que toma tres parámetros: un valor, un límite inferior y un límite superior. Devuelve el valor restringido dentro de los límites (devuelve el límite inferior si el valor es menor que el inferior, el límite superior si el valor es mayor que el superior, de lo contrario devuelve el valor mismo).
swapValues — una función de plantilla que toma dos referencias del mismo tipo e intercambia sus valores.
main.cpp: Lee seis entradas (cada una en una línea separada):
1. Primer entero
2. Segundo entero
3. Un valor double para restringir (clamp)
4. Límite inferior (double)
5. Límite superior (double)
6. Un carácter
Demuestra tus plantillas realizando lo siguiente:
1. Encontrar el mínimo de los dos enteros e imprimir: Min of <a> and <b>: <result>
2. Encontrar el mínimo de los caracteres 'm' y tu carácter de entrada, imprimiendo: Min of m and <char>: <result>
3. Restringir (clamp) el valor double e imprimir: Clamp <value> to [<low>, <high>]: <result>
4. Restringir (clamp) el primer entero al rango [0, 100] e imprimir: Clamp <value> to [0, 100]: <result>
5. Intercambiar los dos enteros e imprimir: After swapValues: <a>, <b>

Por ejemplo, con las entradas 25, 10, 3.7, 1.0, 5.0, y z:

Min of 25 and 10: 10
Min of m and z: m
Clamp 3.7 to [1, 5]: 3.7
Clamp 25 to [0, 100]: 25
After swapValues: 10, 25

Observa cómo cada función de plantilla funciona perfectamente con enteros, doubles y caracteres; el compilador genera la versión adecuada para cada tipo que utilices. Tu función swapValues debe modificar las variables originales a través de referencias, demostrando que las plantillas funcionan con parámetros de referencia al igual que las funciones regulares.

Hoja de referencia

Las plantillas de funciones le permiten escribir funciones genéricas que funcionan con múltiples tipos. Utilice la palabra clave template seguida de los parámetros de la plantilla:

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

El compilador genera automáticamente versiones específicas de tipo a través de la instanciación de plantillas:

maximum(5, 3);        // Genera la versión int
maximum(3.14, 2.71);  // Genera la versión double
maximum('a', 'z');    // Genera la versión char

Puede especificar explícitamente el tipo cuando sea necesario:

maximum<double>(5, 3.14);  // Fuerza la versión double

Las plantillas admiten múltiples parámetros de tipo:

template <typename T, typename U>
void printPair(T first, U second) {
    std::cout << first << ", " << second << std::endl;
}

printPair(42, "hello");  // T=int, U=const char*

Las plantillas funcionan con parámetros de referencia para modificar los valores originales:

template <typename T>
void swapValues(T& a, T& b) {
    T temp = a;
    a = b;
    b = temp;
}

Las plantillas de funciones proporcionan polimorfismo en tiempo de compilación con cero sobrecarga en tiempo de ejecución, lo que las hace ideales para código genérico donde el rendimiento es crítico.

Pruébalo tú mismo

#include <iostream>
#include "MathUtils.h"
using namespace std;

int main() {
    // Leer entradas
    int a, b;
    double value, low, high;
    char ch;
    
    cin >> a;
    cin >> b;
    cin >> value;
    cin >> low;
    cin >> high;
    cin >> ch;
    
    // TODO: Usar la plantilla minimum para encontrar el mínimo de dos enteros
    // Imprimir: "Min of <a> and <b>: <result>"
    
    // TODO: Usar la plantilla minimum para encontrar el mínimo de 'm' y el carácter de entrada
    // Imprimir: "Min of m and <char>: <result>"
    
    // TODO: Usar la plantilla clamp en el valor double
    // Imprimir: "Clamp <value> to [<low>, <high>]: <result>"
    
    // TODO: Usar la plantilla clamp en el primer entero con el rango [0, 100]
    // Imprimir: "Clamp <value> to [0, 100]: <result>"
    
    // TODO: Usar la plantilla swapValues en los dos enteros
    // Imprimir: "After swapValues: <a>, <b>"
    
    return 0;
}