Menu
CoddyTech

Plantillas de clases

Parte de la sección Programación Orientada a Objetos del Journey de C++ de Coddy. Lección 65 de 104.

Así como las plantillas de funciones te permiten escribir funciones independientes del tipo, las plantillas de clase te permiten crear clases independientes del tipo. Así es como funcionan los contenedores como std::vector: defines la estructura una sola vez y el compilador genera versiones específicas para cada tipo que uses.

template <typename T>
class Box {
    T value;
public:
    Box(T v) : value(v) {}
    T getValue() const { return value; }
    void setValue(T v) { value = v; }
};

int main() {
    Box<int> intBox(42);
    Box<std::string> strBox("Hello");
    
    std::cout << intBox.getValue() << std::endl;  // 42
    std::cout << strBox.getValue() << std::endl;  // Hello
}

Normalmente especificas el tipo entre corchetes angulares al crear objetos a partir de plantillas de clase. Desde C++17, el compilador también puede deducirlo a partir de los argumentos del constructor (Box b(42); crea un Box<int>), pero cuando no hay argumentos de los que deducirlo, debes escribir el tipo. Después, el compilador genera una definición completa de la clase para ese tipo específico.

Las plantillas de clase pueden tener varios parámetros de tipo e incluso parámetros que no sean de tipo, como los números enteros:

template <typename T, int Size>
class FixedArray {
    T data[Size];
public:
    T& operator[](int index) { return data[index]; }
    int size() const { return Size; }
};

FixedArray<double, 5> arr;  // Arreglo de 5 valores de tipo double
arr[0] = 3.14;

Al definir funciones miembro fuera de la clase, debes repetir la declaración de la plantilla:

template <typename T>
class Container {
    T* data;
public:
    Container();
    ~Container();
};

template <typename T>
Container<T>::Container() : data(nullptr) {}

template <typename T>
Container<T>::~Container() { delete data; }

Las plantillas de clase constituyen la base de la programación genérica en C++ y te permiten escribir estructuras de datos reutilizables que funcionan con cualquier tipo.

challenge icon

Desafío

Fácil

Construyamos un sistema de almacenamiento genérico usando plantillas de clase para crear un contenedor flexible que pueda contener cualquier tipo de dato. Organizarás tu clase de plantilla en un archivo de encabezado y demostrarás su versatilidad con distintos tipos en tu programa principal.

Crearás dos archivos:

  • Storage.h: Define una plantilla de clase llamada Storage que funcione como un contenedor simple para un único valor, con algunas operaciones útiles:

    Tu plantilla Storage debe tener:

    • Un miembro privado para almacenar el valor
    • Un constructor que reciba un valor inicial
    • Un método getValue() que devuelva el valor almacenado
    • Un método setValue() que actualice el valor almacenado
    • Un método isEmpty() que devuelva true si el valor es igual al valor construido por defecto del tipo T, y false en caso contrario

    Crea también una plantilla de clase llamada Pair con dos parámetros de tipo, que almacene dos valores relacionados:

    • Miembros privados para el primer y el segundo valor (que pueden ser de tipos diferentes)
    • Un constructor que inicialice ambos valores
    • Métodos getFirst() y getSecond() para obtener cada valor
    • Un método display() que imprima: (<first>, <second>)
  • main.cpp: Lee cuatro entradas (cada una en una línea distinta):
    1. Un valor entero
    2. Un nuevo valor entero
    3. Un valor de cadena
    4. Un valor de tipo double

    Demuestra tus plantillas de la siguiente manera:

    1. Crea un Storage<int> con el primer entero e imprime: Int storage: <value>
    2. Actualízalo con el segundo entero usando setValue() y después imprime: Updated: <value>
    3. Crea un Storage<std::string> con la entrada de cadena e imprime: String storage: <value>
    4. Comprueba si el almacenamiento de la cadena está vacío e imprime: Is empty: <true/false> (imprime true o false)
    5. Crea un Pair<std::string, double> con los valores de cadena y double, y después llama a display()
    6. Crea un Pair<int, int> con las dos entradas enteras, y después llama a display()

Por ejemplo, con las entradas 42, 100, Hello y 3.14:

Int storage: 42
Updated: 100
String storage: Hello
Is empty: false
(Hello, 3.14)
(42, 100)

Observa cómo la misma plantilla Storage funciona sin problemas con enteros y cadenas, y cómo Pair puede combinar distintos tipos. El compilador genera definiciones de clase independientes para cada combinación de tipos que uses. Recuerda usar la sintaxis template <typename T> para las plantillas de un solo tipo y template <typename T, typename U> para las plantillas con varios parámetros de tipo.

Pruébalo tú mismo

#include <iostream>
#include <string>
#include "Storage.h"

using namespace std;

int main() {
    // Lee las entradas
    int intValue1;
    int intValue2;
    string strValue;
    double doubleValue;
    
    cin >> intValue1;
    cin >> intValue2;
    cin >> strValue;
    cin >> doubleValue;
    
    // TODO: Crea Storage<int> con el primer entero e imprime: Int storage: <value>
    
    // TODO: Actualiza con el segundo entero usando setValue() e imprime: Updated: <value>
    
    // TODO: Crea Storage<std::string> con la cadena de entrada e imprime: String storage: <value>
    
    // TODO: Comprueba si el almacenamiento de la cadena está vacío e imprime: Is empty: true/false
    
    // TODO: Crea Pair<std::string, double> con la cadena y el valor double; llama a display()
    
    // TODO: Crea Pair<int, int> con ambos enteros; llama a display()
    
    return 0;
}
quiz iconPonte a prueba

Esta lección incluye un breve cuestionario. Empieza la lección para responderlo y registrar tu progreso.

Todas las lecciones de Programación Orientada a Objetos

Practica por tu cuenta: Compilador de C++ online