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.
Desafío
FácilConstruyamos 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 llamadaStorageque funcione como un contenedor simple para un único valor, con algunas operaciones útiles:Tu plantilla
Storagedebe 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 devuelvatruesi el valor es igual al valor construido por defecto del tipo T, yfalseen caso contrario
Crea también una plantilla de clase llamada
Paircon 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()ygetSecond()para obtener cada valor - Un método
display()que imprima:(<first>, <second>)
main.cpp: Lee cuatro entradas (cada una en una línea distinta):- Un valor entero
- Un nuevo valor entero
- Un valor de cadena
- Un valor de tipo double
Demuestra tus plantillas de la siguiente manera:
- Crea un
Storage<int>con el primer entero e imprime:Int storage: <value> - Actualízalo con el segundo entero usando
setValue()y después imprime:Updated: <value> - Crea un
Storage<std::string>con la entrada de cadena e imprime:String storage: <value> - Comprueba si el almacenamiento de la cadena está vacío e imprime:
Is empty: <true/false>(imprimetrueofalse) - Crea un
Pair<std::string, double>con los valores de cadena y double, y después llama adisplay() - Crea un
Pair<int, int>con las dos entradas enteras, y después llama adisplay()
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;
}
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
1Fundamentos de la POO
Archivos externosCompilación y construcción en C++Archivos de cabecera y archivos fuenteEspacios de nombres y ámbitoIntroducción a la POO en C++Clases y objetosEl puntero 'this'Métodos (funciones miembro)Atributos (miembros de datos)Fundamentos de constructores y destructoresRepaso: calculadora sencilla4Propiedades de clase
Miembros de instancia vs. estáticosGetters y settersFunciones miembro constPalabra clave mutableMétodos y variables estáticosFunciones y clases friendRepaso: gestor de cuentas bancarias7Herencia
Herencia básicaNiveles de acceso en la herenciaOrden de llamada de constructores y destructoresSobrescritura de métodosFunciones virtuales y VTableHerencia múltipleHerencia virtualRepaso: jerarquía de empleados2Gestión de memoria
Memoria de pila vs. heapPunteros y referenciasMemoria dinámica (new/delete)Punteros inteligentes en C++RAII en C++Repaso: gestor de arreglos dinámicos5Encapsulación
Especificadores de acceso en C++Especificadores de acceso en profundidadOcultación de informaciónStruct vs. classClases anidadas e internasRepaso: sistema de registros de estudiantes8Polimorfismo
Polimorfismo en compilación y en tiempo de ejecuciónSobrecarga de funcionesRepaso de las funciones virtualesFunciones virtuales purasClases abstractasDiseño de interfaces en C++Conversión dinámica y RTTIRepaso: calculadora de formas11Conceptos avanzados de POO
Composición frente a herenciaMixins mediante CRTPIdiom PimplBorrado de tiposClases enum y tipado fuerteManejo de excepciones en POOJerarquías de excepciones personalizadas14Patrones de diseño, parte 2
Patrón CommandPatrón AdapterPatrón DecoratorPatrón Template MethodPatrón StatePatrón CompositeRAII como patrón3Constructores y destructores
Constructor predeterminadoConstructor con parámetrosConstructor de copiaConstructor de movimientoListas de inicialización del constructorConstructores delegadosAnálisis detallado del destructorRegla de tres / cinco / ceroRepaso: clase String6Sobrecarga de operadores
Introducción a la sobrecarga de operadoresSobrecarga de operadores aritméticosSobrecarga de operadores de comparaciónOperadores de flujoSobrecarga del operador de asignaciónSobrecarga de los operadores [] y ()Operadores de conversión de tipoRepaso: clase Matrix9Plantillas
Plantillas de funcionesPlantillas de clasesEspecialización de plantillasPlantillas variádicasFundamentos de SFINAE y rasgos de tiposRepaso: contenedor genéricoPractica por tu cuenta: Compilador de C++ online