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 después darte cuenta de que necesitas la misma lógica para valores de tipo double y, de nuevo, para cadenas. Sin plantillas, escribirías funciones casi idénticas para cada tipo. Las plantillas de función resuelven esto al permitirte escribir la lógica una sola vez y hacer que el compilador genere automáticamente versiones específicas para cada tipo.

Una plantilla de función utiliza la palabra clave template seguida de parámetros de plantilla entre corchetes 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 denomina 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

Los templates 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 de tiempo de ejecución nula en comparación con las funciones virtuales, lo que hace que las plantillas sean ideales para código genérico crítico para el rendimiento.

Desafío

Fácil

Construyamos un conjunto de herramientas de utilidad mediante plantillas de funciones para crear operaciones reutilizables que funcionen con cualquier tipo compatible. Organizarás tus funciones genéricas en un archivo de encabezado 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 plantilla que recibe dos valores del mismo tipo y devuelve el menor.
clamp: una función plantilla que recibe tres parámetros: un valor, un límite inferior y un límite superior. Devuelve el valor restringido dentro de los límites (devuelve low si value es menor que low, high si value es mayor que high; de lo contrario, devuelve el propio valor).
swapValues: una función plantilla que recibe 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 que restringir
4. Límite inferior (double)
5. Límite superior (double)
6. Un carácter
Demuestra tus plantillas mediante 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 de tu carácter de entrada, e imprimir: Min of m and <char>: <result>
3. Restringir el valor double e imprimir: Clamp <value> to [<low>, <high>]: <result>
4. Restringir 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 plantilla funciona perfectamente con enteros, doubles y caracteres: el compilador genera la versión apropiada para cada tipo que utilices. Tu función swapValues debe modificar las variables originales mediante referencias, demostrando que las plantillas funcionan con parámetros de referencia igual que las funciones normales.

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: Usa la plantilla minimum para encontrar el mínimo de dos enteros
    // Imprimir: "Min of <a> and <b>: <result>"
    
    // TODO: Usa la plantilla minimum para encontrar el mínimo de 'm' y el carácter de entrada
    // Imprimir: "Min of m and <char>: <result>"
    
    // TODO: Usa la plantilla clamp en el valor double
    // Imprimir: "Clamp <value> to [<low>, <high>]: <result>"
    
    // TODO: Usa la plantilla clamp en el primer entero con rango [0, 100]
    // Imprimir: "Clamp <value> to [0, 100]: <result>"
    
    // TODO: Usa la plantilla swapValues en los dos enteros
    // Print: "After swapValues: <a>, <b>"
    
    return 0;
}