Plantillas
Tecnología de la Programación
Javier Nieves Acedo
Si no queremos empezar
la casa por el tejado
Hay que plantar unas buenas
bases
Así que
antes de la…
Hay que empezar con las
plantillas …
Problema de Partida (1)
 En un proyecto…
int Max(int a, int b)
{
return a > b ? a: b;
}
void main()
{
int i1, i2, iMayor;
iMayor = Max(i1, i2);
}
Problema de Partida (2)
 Y si quiero hacer esto…
void main()
{
int i1, i2, iMayor;
float f1, f2, fMayor;
char c1, c2, cMayor;
iMayor = Max(i1, i2);
fMayor = Max(f1, f2);
cMayor = Max(c1, c2);
}
Problema de Partida (3)
 Primera solución: Sobrecarga
int Max(int a, int b)
{
return a > b ? a: b;
}
float Max(float a, float b)
{
return a > b ? a: b;
}
char Max(char a, char b)
{
return a > b ? a: b;
}
Problema de Partida (4)
 Segunda solución: Macros
#define MAX(a, b) (a) > (b) ? (a) : (b)
No da Error pero no se comprueban los
tipos de los datos
Problema de Partida (y4)
 Tercera solución:
Entremos de lleno con los
tipos genéricos …
Tipos Genéricos (1)
 Plantillas == 3ª forma de Polimorfismo
 A función de una plantilla es…
 Escribir código genérico
 Generar posteriormente funciones o clases
 También se llaman tipos parametrizados
Tipos Genéricos (y 2)
 Cuando utilizarlas…
 Haya que definir diferentes pero muy
similares funciones o clases.
 Hay dos tipos:
 Plantillas de Funciones
 Plantillas de Clases
Y para
programarlo…
Plantillas Generadoras de Funciones (1)
 Sintaxis:
template <class P> función
 Template es palabra reservada
 <> lista de identificadores precedidos de
class (no OO) y separados por comas (‘,’)
 Los identificadores son parámetros de
sustitución
Plantillas Generadoras de Funciones (2)
 Solución al problema de partida (1):
template <class IDENT>
IDENT Max(IDENT a, IDENT b)
{
return a > b ? a : b;
}
Plantillas Generadoras de Funciones (y 3)
 Solución al problema de partida (y 2):
int Max(int, int);
float Max(float, float);
char Max(char, char);
void main()
{
int i1, i2, iMayor;
float f1, f2, fMayor;
char c1, c2, cMayor;
iMayor = Max(i1, i2);
fMayor = Max(f1, f2);
cMayor = Max(c1, c2);
}
Plantillas Generadoras de Clases (1)
 Usan una sintaxis similar a las de funciones.
 Con ellas se pueden generar más de una
clase con tipos diferentes.
 Uso más frecuente
 Contenedores (por ejemplo STL)
Plantillas Generadoras de Clases (2)
 Ejemplo (1):
const int TRUE = 1;
const int FALSE = 0;
template <class TIPO>
class Pila
{
private:
TIPO * P;
int Cim;
int MaxLong;
Plantillas Generadoras de Clases (2)
 Ejemplo (2):
public:
Pila(int Tam = 1000) : MaxLong(Tam)
{
P = new TIPO[Tam];
Cim = -1;
}
~Pila() {delete [] P;}
void Push(TIPO El) {P[++Cim] = El;}
TIPO Pop() {return(P[Cim--]);}
TIPO Cima() {return(P[Cim]);}
int Vacia() {return((Cim == -1 ? 1: 0));}
int Llena() {return((Cim == MaxLong-1)?0: 1);}
};
Plantillas Generadoras de Clases (y 3)
 Ejemplo (y 3):
void main()
{
Pila<int> PilaInt(10);
Pila<char> PilaChar(15);
for (int i=65; i <= 95; i += 5)
{
cout << "Poniendo en pila 1 ... "
<< i; cout << "y en pila 2..."
<< char(i) <<"\n";
PilaInt.Push(i);
PilaChar.Push(char(i));
}
}
Plantillas con Varios Parámetros de
Sustitución (1)
template <class T, int CONSTANTE>
class Suma
{
T x;
public:
Suma(T a):x(a){}
Suma(void){}
void IniSuma(T a){ x=(T) a;}
T Sumar(T a)
{T w = CONSTANTE; return a+w+x;}
};
Suma <int, 1> SI
Plantillas con Varios Parámetros de
Sustitución (y 2)
template <class T, class U, int CONSTANTE>
class Suma
{
T x; U y;
public:
Suma(T a=0, U b=0):x(a),y(b){}
void IniSuma(T a, U b){ x=(T)a; y =(U)b; }
int sumar(U b)
{
T w = CONSTANTE;
return int(w+x)+int(y)+U(b);
}
};
Suma <int, int, 1> SI
Pero en
memoria qué
sucede…
Uso de Memoria
 Las plantillas son una declaración (van en el
.h)
 El compilador crea el código para cada
plantilla.
 Beneficio: optimizada para cada tipo
 Inconveniente: tamaño del programa crece
(ocupa más memoria pero sin afectar al
rendimiento)
Ahora te toca a
ti
Ejercicio
 Plantilla para una clase Vector de tipo genérico.
 Con un array y su tamaño (gestionará su propia
memoria).
 Métodos:
 Constructores (defecto, copia).
 Operador de asignación
 Recoger el tamaño, recoger un elemento, añadir
un elemento al final, eliminar un elemento por
posición.
La STL se va a utilizar
igual
Plantillas
Tecnología de la Programación
Javier Nieves Acedo
Descargar

Plantillas