Qué son los Genéricos y Templates en programación

Los templates y generics son mecanismos de programación genérica que permiten definir funciones, clases o estructuras que pueden operar con cualquier tipo de dato.

Si alguna vez te has encontrado copiando y pegando una función entera solo para cambiar int por float en la definición de los parámetros, entonces has sentido el dolor que venimos a solucionar en el tema de hoy.

Aunque hay diferencias técnicas en como funcionan Templates y Genéricos, el concepto es el mismo. Escribir con código que funcione con tipos que aún no conocemos.

Es como diseñar el plano de una caja sin decidir todavía qué vamos a guardar dentro, o una función que cambia para adaptarse a lo que le pasas.

Al principio pueden intimidar, especialmente cuando ves definiciones complejas como <T, U, V> where T : new(). Pero son una herramienta fundamental para construir librerías y frameworks

El Problema: La duplicidad de código

Imagina que queremos crear una función sencilla para intercambiar dos valores entre dos variables (Swap).

En un lenguaje fuertemente tipado (sin genéricos), tendríamos que hacer esto:

// Versión para enteros
void Swap(int a, int b) { ... }

// Versión para flotantes
void Swap(float a, float b) { ... }

// Versión para strings
void Swap(string a, string b) { ... }

La solución: Tipos como parámetros

La programación genérica nos permite definir una función (o una clase) donde el tipo de dato es un parámetro más.

Igual que una función recibe argumentos como valores (x = 5), una función genérica recibe argumentos de tipo (T = int).

La T (de Type) es simplemente una convención muy usada, pero podrías usar cualquier nombre. La sintaxis suele usar los símbolos < >.

// Pseudo-código Genérico
class Caja<T> 
{
    private T contenido;

    public void Guardar(T objeto) {
        this.contenido = objeto;
    }

    public T Sacar() {
        return this.contenido;
    }
}

¿Templates o genéricos? ¿Es lo mismo?

Conceptualmente, básicamente sí, son lo mismo. Aunque la implementación interna es distinta

Constraints

Los genéricos son una herramienta muy potente, pero normalmente necesitamos “delimitarlos” de alguna forma para que sean útiles. Si T puede ser cualquier cosa, entonces no puedo hacer mucho con ello.

Para solucionar esto, usamos las Constraints (restricciones). Le decimos al compilador:

Acepto cualquier tipo T, siempre y cuando T cumpla con estas condiciones

Dependiendo del lenguaje, la sintaxis varía (where, extends, concepts), pero la idea es:

// Solo acepto tipos que sean "Comparables" entre sí
class Ordenador<T> where T : IComparable 
{
    public T Mayor(T a, T b) 
    {
        // Como sé que T es IComparable, puedo usar el método CompareTo
        if (a.CompareTo(b) > 0) return a;
        return b;
    }
}

Sintaxis de templates y generics en distintos lenguajes

Aunque el concepto es similar, la sintaxis varía según el lenguaje. A continuación, veremos ejemplos en varios lenguajes populares.

#include <iostream>

// Función template para intercambiar valores
template <typename T>
void intercambiar(T &a, T &b) {
    T temp = a;
    a = b;
    b = temp;
}

int main() {
    int x = 5, y = 10;
    intercambiar(x, y);
    std::cout << "x: " << x << ", y: " << y << std::endl;  // Salida: x: 10, y: 5

    std::string s1 = "Hola", s2 = "Mundo";
    intercambiar(s1, s2);
    std::cout << "s1: " << s1 << ", s2: " << s2 << std::endl;  // Salida: s1: Mundo, s2: Hola

    return 0;
}

public class Main {
    // Método genérico para intercambiar valores
    public static <T> void intercambiar(T[] array, int i, int j) {
        T temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }

    public static void main(String[] args) {
        Integer[] numeros = {5, 10};
        intercambiar(numeros, 0, 1);
        System.out.println("numeros[0]: " + numeros[0] + ", numeros[1]: " + numeros[1]);  // Salida: numeros[0]: 10, numeros[1]: 5

        String[] palabras = {"Hola", "Mundo"};
        intercambiar(palabras, 0, 1);
        System.out.println("palabras[0]: " + palabras[0] + ", palabras[1]: " + palabras[1]);  // Salida: palabras[0]: Mundo, palabras[1]: Hola
    }
}

using System;

class Program
{
    // Método genérico para intercambiar valores
    public static void Intercambiar<T>(ref T a, ref T b)
    {
        T temp = a;
        a = b;
        b = temp;
    }

    static void Main()
    {
        int x = 5, y = 10;
        Intercambiar(ref x, ref y);
        Console.WriteLine($"x: {x}, y: {y}");  // Salida: x: 10, y: 5

        string s1 = "Hola", s2 = "Mundo";
        Intercambiar(ref s1, ref s2);
        Console.WriteLine($"s1: {s1}, s2: {s2}");  // Salida: s1: Mundo, s2: Hola
    }
}

// Función genérica para intercambiar valores
function intercambiar<T>(a: T, b: T): [T, T] {
    return [b, a];
}

let x = 5, y = 10;
[x, y] = intercambiar(x, y);
console.log(`x: ${x}, y: ${y}`);  // Salida: x: 10, y: 5

let s1 = "Hola", s2 = "Mundo";
[s1, s2] = intercambiar(s1, s2);
console.log(`s1: ${s1}, s2: ${s2}`);  // Salida: s1: Mundo, s2: Hola