GENERICIDAD Es una propiedad que permite definir una clase o función sin especificar el tipo de datos de uno o mas de sus parámetros (Módulos Parametrizados). Es decir, se puede cambiar la clase para adaptarla a los diferentes usos sin tener que reescribirla. MÓDULOS GENÉRICOS O PARAMETRIZADOS 1. Llamadas también CLASES CONTENEDORAS o CLASES GENÉRICAS: Contienen objetos de algún otro tipo. 2. Este módulo no es directamente útil, más bien es un patrón de módulos. 3. Los Módulos reales (instancias del Módulo Genérico) se obtienen proporcionando tipos reales para cada uno de los tipos genéricos. 4. Estas clases se definen con independencia del tipo de los objetos contenidos, y es el usuarios de la clase quien especifica el tipo de argumento de la clase en el momento que se instancia

DEFINICIÓN:  Es una construcción que permite escribir funciones y clases muy generales que pueden aplicarse a objetos de tipos diferentes.  Permiten aumentar la reutilización.  Se pueden tener :- Plantillas de Funciones - Plantillas de Clases  Las plantillas se declaran normalmente en un archivo de Cabecera CARACTERÍSTICAS: - Es fácil la utilización de parametrizacion de tipos. - No afecta la velocidad de compilación y enlace. - Es simple y transportable.

DEFINICIÓN: Especifica un conjunto infinito de funciones sobrecargadas y describe las funciones genéricas de una función. template Tipo_Retorno Nombre_Función (Lista_Parámetros) { //Cuerpo de la función } ejm: template T& F (T Parámetro) {...} template T F (int a, T b) {...} template T F (T a, T b) {...} Pueden tener varios parámetros genéricos. template T1 F (T1 a, T2 b) {...} No puede ser vacía

Template T min(T a, T b) { return a < b ? a: b; } Int main() { int ia=1, ib=5; cout << "Menor: " << min(ia, ib) << endl; char la=‘a’, lb=‘n’; cout << "Menor: " << min(la, lb) << endl; float fa=88.4, fb=19.9; cout << "Menor: " << min(fa, fb) << endl; }

 Permiten definir Clases Genéricas que permiten manipular diferentes tipos de datos.  Una Clases Genéricas o Plantilla de Clase, define todos los algoritmos usados por la clase, pero la especificación del tipo de dato que se manipula se hace mediante un parámetro cuando se crean los objetos de dicha clase.  Las Clases Genéricas son útiles cuando una clase contiene una lógica generalizable.  Usando Clases Genéricas se pueden crear clases que mantengan colas, pilas, listas enlazadas, y similares para cualquier tipo de dato.

Los compiladores (c++ Builder incluido) necesitan que la plantilla completa (Clases e implementaciones de sus métodos) se encuentre en un único archivo.h (sin.cpp). CONSTRUCTOR: template class NombreClase { //... } Tipo de dato definido por el usuario utilizado por la plantilla (Tipo Genérico) Nombre de la clase genérica del tipo parametrizado para la plantilla template NombreClase :: NombreClase (Parámetros) { //... }

FUNCIONES MIEMBRO: La manipulación de un una plantilla requiere tres etapas: 1. Declaración del Tipo parametrizado (Ejm: Pila) 2. Implementación de la Pila 3. Creación de una instancia especifica de la plantilla template Tipo_Retorno NombreClase :: NombreFuncion (Parámetros) { //... }

ARGUMENTOS DE PLANTILLAS  Los parámetros de una plantilla pueden ser cadenas de caracteres, nombres de funciones y expresiones de constantes. Ejm: template class Vector { T Dato [n]; //... }  Dos instancias son compatibles si sus argumentos tipo son iguales y sus argumentos expresiones tienen el mismo valor. Ejm: Vector V1 Vector V2 Nota:Una Clase Plantilla es una clase construida a partir de una plantilla de clases

PREGUNTAS: 1. Cuales son las diferencias entre estos dos conceptos? 2. Se puede sustituir el polimorfismo por una plantilla? 3. Cual de las dos características es mejor?

 Una función es polimórfica si supone tipos de datos diferentes, además puede tener diferentes parámetros y diferente implementación.  El polimorfismo necesita punteros y su generalidad se limita a jerarquías. Recuérdese que el polimorfismo se basa en que en el momento de compilación se desconoce a qué clase de la jerarquía va a apuntar un puntero que se ha definido como puntero a la clase base. Desde este punto de vista las plantillas pueden considerarse como una ampliación del polimorfismo.  Una función es una función plantilla si se diseña, define e implementa pensando en la generalidad, evitando cualquier dependencia en tipos de datos.  Una desventaja de las plantillas es que tienden a crear un código ejecutable grande porque se crean tantas versiones de las funciones como son necesarias.  Una función polimórfica se puede ejecutar dinámicamente con parámetros de tipos diferentes.

template class Nodo { TIPO Valor; Nodo *Siguiente; public: Nodo(); Nodo(TIPO v, Nodo *Sig); TIPO GetValor(); Nodo * GetSgt(); }; template class Pila { Nodo *Ultimo; public: Pila(); ~Pila(); void Push(TIPO v); TIPO Pop(); }; EJEMPLO template Nodo ::Nodo() { Siguiente = NULL; Valor = -1; } template Nodo ::Nodo(TIPO v, Nodo *Sig) { Valor = v; Siguiente = Sig; } template TIPO Nodo ::GetValor() { return Valor;} template Nodo * Nodo ::GetSgt() { return Siguiente;}

template Pila ::Pila () { Ultimo = NULL; } template Pila ::~Pila() { while(Ultimo) Pop(); } template void Pila ::Push (TIPO v) { Nodo *Nuevo; /* Crear un Nodo nuevo */ Nuevo = new Nodo (v, Ultimo); /* Ahora, el comienzo de nuestra Pila es en nuevo Nodo */ Ultimo = Nuevo; } template TIPO Pila ::Pop() { /*Variable auxiliar para manipular Nodo*/ Nodo *Nodo; TIPO v; /*Variable auxiliar para retorno*/ /*Si no hay Nodos en la Pila retornamos 0*/ if(!Ultimo) return 0; /*Si hay nodos, Nodo apunta al primer elemento de la Pila*/ Nodo = Ultimo; /*Se asigna a la Pila toda la Pila menos el primer elemento */ Ultimo = Nodo->GetSgt(); /*Guardar el Valor de retorno*/ v = Nodo->GetValor(); delete Nodo; /* Borrar el Nodo */ return v; }

int main() { Pila iPila; Pila fPila; Pila cPila; Pila sPila; // Prueba con iPila.Push(20); iPila.Push(10); cout<<iPila.Pop()<< ","; iPila.Push(40); iPila.Push(30); cout<<iPila.Pop()<<","; iPila.Push(90); cout<<iPila.Pop()<<","; cout<<iPila.Pop()<<endl; //Prueba con fPila.Push(20.01); fPila.Push(10.02); cout<<fPila.Pop()<<","; fPila.Push(40.03); fPila.Push(30.04); cout<<fPila.Pop()<<","; fPila.Push(90.05); cout<<fPila.Pop()<<","; cout<<fPila.Pop()<<endl; //Prueba con cPila.Push('x'); cPila.Push('y'); cout<<cPila.Pop()<<","; cPila.Push('a'); cPila.Push('b'); cout<<cPila.Pop()<<","; cPila.Push('m'); cout<<cPila.Pop()<<","; cout<<cPila.Pop()<<endl; //Prueba con sPila.Push("Hola"); sPila.Push("somos"); cout<<sPila.Pop()<<","; sPila.Push("programadores"); sPila.Push("buenos"); cout<<sPila.Pop()<<","; sPila.Push("!!!!"); cout<<sPila.Pop()<<","; cout<<sPila.Pop()<<endl; return 0; }

 Como sabemos la reutilización de software, con el ahorro de tiempo y esfuerzo que conlleva, es uno de los objetivos primordiales de la POO.  La reutilización se consigue básicamente utilizando clases existentes y derivando nuevas clases a partir de clases existentes (herencia). En resumidas cuentas, aprovechando las clases existentes.  Así, cuanto más fácil sea aprovechar las clases existentes, más se fomentará la reutilización. Y las clases genéricas son adecuadas para muchas más situaciones que las que no son genéricas.  Una biblioteca de clases genéricas es, por definición, mucho más útil que una de clases no genéricas. C++ proporciona una biblioteca de clases genéricas: la Biblioteca Estándar de Plantillas (STL).  La STL es una colección de componentes reutilizables implementados como clases genéricas (plantillas).  Las clases han sido optimizadas para dotarlas de la mayor eficiencia.