Apuntes de Clases (continuación)

Transcripción

1 Apuntes de Clases (continuación) Plantillas: Según va aumentando la complejidad de nuestros programas y sobre todo, de los problemas a los que nos enfrentamos, descubrimos que tenemos que repetir una y otra vez las mismas estructuras. Por ejemplo, a menudo tendremos que implementar arrays dinámicos para diferentes tipos de objetos, o listas dinámicas, pilas, colas, árboles, etc. El código es similar siempre, pero estamos obligados a rescribir ciertas funciones que dependen del tipo o de la clase del objeto que se almacena. Las plantillas (templates) nos permiten parametrizar estas clases para adaptarlas a cualquier tipo de dato. Vamos a desarrollar un ejemplo sencillo de un array que pueda almacenar cualquier objeto. Aunque más adelante veremos que se presentan algunas limitaciones y veremos cómo solucionarlas. Con lo que ya sabemos, podemos crear fácilmente una clase que encapsule un array de, por ejemplo, enteros. Veamos el código de esta clase: #include <iostream> using namespace std; class TablaInt { TablaInt(int nelem); ~TablaInt(); int& operator[](int indice) { return pint[indice]; int *pint; int nelementos; ; TablaInt::TablaInt(int nelem) : nelementos(nelem) { pint = new int[nelementos]; TablaInt::~TablaInt() { delete[] pint; int main() { TablaInt TablaI(10); for(int i = 0; i < 10; i++) TablaI[i] = 10-i; for(int i = 0; i < 10; i++) cout << TablaI[i] << endl; cin.get(); return 0; Bien, la clase TablaInt nos permite crear arrays de la dimensión que queramos, para almacenar enteros. Quizás pienses que para eso no hace falta una clase, ya que podríamos haber declarado sencillamente: int TablaI[10]; Además, la clase TablaInt nos permite hacer cosas como esta: int elementos = 24; TablaInt TablaI(elementos); Recordarás que no está permitido usar variables para indicar el tamaño de un array. Pero no sólo eso, en realidad esta podría ser una primera aproximación a una clase TablaInt que nos permitiría aumentar el número elementos o disminuirlo durante la ejecución, definir constructores copia, o sobrecargar operadores suma, resta, etc. 1

2 La clase para Tabla podría ser mucho más potente de lo que puede ser un array normal, pero dejaremos eso para otra ocasión. Supongamos que ya tenemos esa maravillosa clase definida para enteros. Qué pasa si ahora necesitamos definir esa clase para números en coma flotante?. Podemos cortar y pegar la definición y sustituir todas las referencias a int por float. Pero, y si también necesitamos esta estructura para cadenas, complejos, o para la clase persona que implementamos en anteriores capítulos?, haremos una versión para cada tipo para el que necesitemos una Tabla de estas características?. Afortunadamente existen las plantillas y (aunque al principio no lo parezca), esto nos hace la vida más fácil. Sintaxis. C++ permite crear plantillas de funciones y plantillas de clases. La sintaxis para declarar una plantilla de función es parecida a la de cualquier otra función, pero se añade al principio una presentación de la clase que se usará como referencia en la plantilla: template <class typename <id>[,...]> <tipo_retorno> <identificador>(<lista_de_parámetros>) { // Declaración de función ; La sintaxis para declarar una plantilla de clase es parecida a la de cualquier otra clase, pero se añade al principio una presentación de la clase que se usará como referencia en la plantilla: template <class typename <id>[,...]> class <identificador_de_plantilla> { // Declaración de funciones // y datos miembro de la plantilla ; Ejemplo template <class T1> Tabla();... ; Del mismo modo, cuando tengamos que definir una función miembro fuera de la declaración de la clase, tendremos que incluir la parte del template y como nombre de la clase incluir la plantilla antes del operador de ámbito (::). Por ejemplo: template <class T1> Tabla<T1>::Tabla() { // Definición del constructor Plantillas de funciones. Un ejemplo de plantilla de función puede ser esta que sustituye a la versión macro de max: T max(t x, T y) { return (x > y)? x : y; ; La ventaja de la versión en plantilla sobre la versión macro se manifiesta en cuanto a la seguridad de tipos. Por supuesto, podemos usar argumentos de cualquier tipo, no han de ser necesariamente clases. Pero cosas como estas darán error de compilación: int a=2; char b= j ; int c=max(a,b); 2

3 El motivo es que a y b no son del mismo tipo. Aquí no hay promoción implícita de tipos. Sin embargo, están permitidas todas las combinaciones en las que los argumentos sean del mismo tipo o clase, siempre y cuando que el operador > esté implementado para esa clase. int a=3, b=5, c; char f= a, g= k, h; c = max(a,b); h = max(f,g); Plantilla para Tabla. Ahora estamos en disposición de crear una plantilla a partir de la clase Tabla que hemos definido antes. Esta vez podremos usar esa plantilla para definir Tablas de cualquier tipo de objeto. Tabla(int nelem); T& operator[](int indice) { return pt[indice]; T *pt; int nelementos; ; Tabla<T>::Tabla(int nelem) : nelementos(nelem) { pt = new T[nElementos]; Tabla<T>::~Tabla() { delete[] pt; Dentro de la declaración y definición de la plantilla, podremos usar los parámetros que hemos especificado en la lista de parámetros del template como si se tratase de comodines. Más adelante, cuando creemos instancias de la plantilla para diferentes tipos, el compilador sustituirá esos comodines por los tipos que especifiquemos. Y ya sólo nos queda por saber cómo declarar Tablas del tipo que queramos. La sintaxis es: <identificador_de_plantilla><<tipo/clase>> <identificador/constructor>; Seguro que se ve mejor con un ejemplo, veamos como declarar Tablas de enteros, punto flotante o valores booleanos: Tabla<int> TablaInt(32); // Tabla de 32 enteros Tabla<float> TablaFloat(12); // Tabla de 12 floats Tabla<bool> TablaBool(10); // Tabla de 10 bools Pero no es este el único modo de proceder. Las plantillas admiten varios parámetros, de modo que también podríamos haber especificado el número de elementos como un segundo parámetro de la plantilla: template <class T, int nelementos> Tabla(); T& operator[](int indice) { return pt[indice]; T *pt; ; template <class T, int nelementos> Tabla<T,nElementos>::Tabla() { 3

4 pt = new T[nElementos]; template <class T, int nelementos> Tabla<T, nelementos>::~tabla() { delete[] pt; La declaración de tablas con esta versión difiere ligeramente: Tabla<int,32> TablaInt; // Tabla de 32 enteros Tabla<float,12> TablaFloat; // Tabla de 12 floats Tabla<bool,10> TablaBool; // Tabla de 10 bools Esta forma tiene una limitación: el argumento nelementos debe ser una constante, nunca una variable. Esto es porque el valor debe conocerse durante la compilación del programa. Las plantillas no son definiciones de clases, sino plantillas que se usan para generar las clases que a su vez se compilarán para crear el programa: #define N const n = 10; int i = 23; Tabla<int,N> TablaInt; // Legal, Tabla de 12 enteros Tabla<float,3*n> TablaFloat; // Legal, Tabla de 30 floats Tabla<char,i> TablaFloat; // Ilegal Vamos a ver un ejemplo completo de cómo aplicar la plantilla anterior a diferentes tipos. Fichero de cabecera que declara y define la plantilla Tabla: // Tabla.h: definición de la plantilla tabla: // C con Clase: Marzo de 2002 #ifndef T_TABLA #define T_TABLA Tabla(int nelem); T& operator[](int indice) { return pt[indice]; int NElementos() const { return nelementos; T *pt; int nelementos; ; Tabla<T>::Tabla(int nelem) : nelementos(nelem) { pt = new T[nElementos]; Tabla<T>::~Tabla() { delete[] pt; #endif Fichero de aplicación de plantilla: // Tabla.cpp: ejemplo de Tabla // C con Clase: Marzo de 2002 #include <iostream> #include "Tabla.h" using namespace std; 4

5 cont int nelementos = 10; int main() { Tabla<int> TablaInt(nElementos); Tabla<float> TablaFloat(nElementos); for(int i = 0; i < nelementos; i++) TablaInt[i] = nelementos-i; for(int i = 0; i < nelementos; i++) TablaFloat[i] = 1/(1+i); for(int i = 0; i < nelementos; i++) { cout << "TablaInt[" << i << "] = " << TablaInt[i] << endl; cout << "TablaFloat[" << i << "] = " << TablaFloat[i] << endl; cin.get(); return 0; Posibles problemas: Ahora bien, supongamos que quieres usar la plantilla Tabla para crear una tabla de cadenas. Lo primero que se nos ocurre hacer probablemente sea: Tabla<char*> TablaCad(15); No hay nada que objetar, todo funciona, el programa compila, y no hay ningún error, pero... es probable que no funcione como esperas. Veamos otro ejemplo: Fichero de aplicación de plantilla: // Tablacad.cpp: ejemplo de Tabla con cadenas // C con Clase: Marzo de 2002 #include <iostream> #include <cstring> #include <cstdio> #include "Tabla.h" using namespace std; const int nelementos = 5; int main() { Tabla<char *> TablaCad(nElementos); char cadena[20]; for(int i = 0; i < nelementos; i++) { sprintf(cadena, "Numero: %5d", i); TablaCad[i] = cadena; strcpy(cadena, "Modificada"); for(int i = 0; i < nelementos; i++) cout << "TablaCad[" << i << "] = " << TablaCad[i] << endl; cin.get(); return 0; Si has compilado el programa y has visto la salida, tal vez te sorprenda algo el resultado: Efectivamente, parece que nuestra tabla no es capaz de almacenar cadenas, o al menos no más de una cadena. La cosa sería aún más grave si la cadena auxiliar fuera liberada, por ejemplo porque se tratase de una variable local de una función, o porque se tratase de memoria dinámica. 5

6 TablaCad[0] = Modificada TablaCad[1] = Modificada TablaCad[2] = Modificada TablaCad[3] = Modificada TablaCad[4] = Modificada Cuál es el problema?. Lo que pasa es que nuestra tabla no es de cadenas, sino de punteros a char. De hecho eso es lo que hemos escrito Tabla<char *>, por lo tanto, no hay nada sorprendente en el resultado. Pero esto nos plantea un problema: cómo nos las apañamos para crear una tabla de cadenas?. 6