Generics en C++: qué son las plantillas y cómo usarlas para principiantes

Generics en C++: para qué sirven y cómo usarlos

¡Hola, amigo! Si estás empezando a aprender C++ y ya te has topado con el concepto de Generics (o plantillas), este artículo es para ti. Muchos principiantes temen a las plantillas, considerándolas algo complejo y mágico. En realidad, es mucho más sencillo. Vamos a entender qué son, para qué sirven y cómo aplicarlas en la práctica.

¿Qué son los Generics (plantillas) en C++?

Imagina que necesitas escribir una función que sume dos números. Escribes una función para int, otra para double, otra para float… ¿De acuerdo, es tedioso y viola el principio DRY (Don't Repeat Yourself).

Aquí es donde entran en juego las plantillas (templates). Es un mecanismo que permite escribir código genérico que funciona con cualquier tipo de dato. En C++, esto es el equivalente a lo que en otros lenguajes se llama Generics (por ejemplo, en Java o C#).

Una plantilla no es una función o clase concreta, sino un "plano" o "receta". El compilador, al ver que usas una plantilla con el tipo int, crea una versión del código para int. Si la usas con double, el compilador crea una versión para double. Esto se llama instanciación de plantilla.

¿Para qué sirven las plantillas? Tres razones principales

1. Reutilización de código

En lugar de escribir 10 funciones para diferentes tipos numéricos, escribes una universal. Esto ahorra tiempo, reduce la cantidad de errores y hace que el código sea más legible.

2. Seguridad de tipos

A diferencia de las macros (#define) o del uso de void*, las plantillas son verificadas por el compilador. Si intentas pasar un tipo inadecuado a una plantilla, el compilador dará un error en la etapa de compilación, no durante la ejecución del programa.

3. Rendimiento

Las plantillas no añaden sobrecarga en tiempo de ejecución. El compilador crea código optimizado para cada tipo específico, y este código funciona tan rápido como si lo hubieras escrito manualmente.

Cómo usar las plantillas: sintaxis y ejemplos

Veamos dos tipos principales de plantillas: plantillas de funciones y plantillas de clases.

Plantillas de funciones

El ejemplo más simple es una función que encuentra el máximo de dos valores.

#include <iostream>#include <string>

// Declaramos la plantilla de funcióntemplate <typename T>T max_value(T a, T b) {    return (a > b) ? a : b;}

int main() {    // Funciona con int    std::cout << max_value(10, 20) << std::endl; // Salida: 20        // Funciona con double    std::cout << max_value(3.14, 2.71) << std::endl; // Salida: 3.14        // Funciona con strings    std::cout << max_value(std::string("apple"), std::string("banana")) << std::endl; // Salida: banana        return 0;}

La palabra clave template le dice al compilador: "Atención, a continuación viene una plantilla". <typename T> es la lista de parámetros de la plantilla. T es un nombre de tipo condicional que será reemplazado por el tipo real al llamar a la función. En lugar de typename se puede usar class; no hay diferencia.

Importante: El compilador deduce automáticamente qué tipo quieres usar según los argumentos pasados. Esto se llama deducción de argumentos de plantilla. Pero también puedes especificar el tipo explícitamente:

std::cout << max_value<double>(10, 20.5) << std::endl; // Especificamos explícitamente el tipo double

Plantillas de clases

Las plantillas de clases permiten crear contenedores de datos universales. Un ejemplo clásico es un análogo simple de std::pair.

#include <iostream>#include <string>

// Plantilla