Tema 4

Tema 4: Genericidad
Tema 4
Genericidad
Versin 3.0 Abril de 2002 Francisco Jos Garca Pealvo
Departamento de Informtica y Automtica - Universidad de Salamanca
Esquema
1. 2. 3. 4. 5. 6. Introduccin Tipos paramtricos y clases genricas Programacin paramtrica Genericidad en C++ Referencias Lecturas complementarias
Tema 4: Genericidad
1. Introduccin
1.1 Presentacin de la genericidad

La genericidad es la posibilidad de definir mdulos parametrizados Soportada por diferentes lenguajes Usualmente los parmetros son tipos Los mensajes genricos permiten la creacin de componentes reutilizables, eliminando la dependencia de la rutina invocada con respecto a lo que se invoca Una clase genrica C[G] es un patrn de tipo que abarca un conjunto infinito de tipos posibles
Se puede obtener uno de esos tipos al proporcionar un parmetro genrico real, que es a su vez un tipo, que corresponde a G
Departamento de Informtica y Automtica - Universidad de Salamanca 4
Tema 4: Genericidad
1.2 Generalizacin de tipos

Abstraccin Conjunto de Libros Genericidad Lista de Personas Lista de Libros Lista de Enlazada de Libros Especializacin
[Meyer, 1997]
Genericidad Lista de Revistas
2. Tipos Paramtricos y Clases Genricas
Tema 4: Genericidad
2.1 Necesidad de la parametrizacin de tipos

En los TAD, la parametrizacin es algo natural
Pila[G] - G es un parmetro formal e indica cualquier tipo contenible en la pila
De una vez se estn definiendo todos los tipos de pila
En un lenguaje OO las clases genricas facilitan un incremento de la calidad de software en cuanto

Aumenta la FIABILIDAD
Favorece hacer al lenguaje fuertemente tipado
Aumenta la REUTILIZACIN
Se hace posible escribir un nico elemento software que abarque variantes de una misma nocin
2.2 Definiciones
Un tipo paramtrico o genrico es un tipo cuya especificacin est definida en funcin de alguna variable de tipo, libre de ser instanciada [Crespo, 2000] Un tipo paramtrico es
Un tipo que describe tipos Una descripcin de objetos
Un tipo paramtrico describe tipos que tienen en comn estructura y comportamiento, pero que se diferencian en el tipo de algunas de sus propiedades La especificacin de una descripcin comn a todos se logra a travs de las variables de tipo Una sustitucin de las variables de tipo da lugar a otro tipo, instancia del tipo paramtrico
8
Tema 4: Genericidad
2.2 Definiciones
Las clases genricas son clases que se definen en funcin de uno o ms parmetros de tipo, los parmetros genricos formales Los parmetros se utilizan en las signaturas y en el cuerpo de la clase genrica con anotaciones de tipo Las clases genricas implementan tipos paramtricos en un lenguaje de programacin orientado a objetos Las clases genricas reciben diferentes nombres en distintos lenguajes:
clases genricas (Eiffel), plantillas (C++), mdulos genricos (Mdula-3)
No todos los lenguajes orientados a objetos permiten definir clases genricas Las clases genricas slo tienen sentido en lenguajes estticamente tipados
Una clase genrica puede definirse como la construccin lingstica en los lenguajes orientados a objetos que se corresponde con la implementacin de un tipo paramtrico [Crespo, 2000]
3. Programacin Paramtrica
10
Tema 4: Genericidad
3.1 Introduccin
La programacin paramtrica y genrica tiene sus orgenes en el trabajo de J. Goguen [Goguen, 1984], y en el posterior de D. Musser y A. Stepanov [Musser and Stepanov, 1989] Se busca la definicin de algoritmos y estructuras de datos en un nivel abstracto o genrico Con esta tcnica los mdulos pueden tener parmetros definidos sobre una interfaz general que describa exactamente qu propiedades se requieren en un entorno para que el mdulo funcione correctamente La reusabilidad se potencia por el mecanismo que permite que otros mdulos instancien los parmetros La idea bsica es maximizar la reusabilidad de los mdulos almacenndolos en la forma ms general posible
3.1 Introduccin
Los bloques constructivos bsicos de la programacin paramtrica son los mdulos paramtricos [Goguen, 1984] Dependiendo del lenguaje, el trmino mdulo puede ser cambiado por tipo, funcin, clase, paquete... Se diferencian cuatro tipos de abstracciones [Musser and Stepanov, 1989]
Datos Algoritmos Estructura Representacin
La programacin genrica depende de que los lenguajes permitan hacer descomposicin de programas en componentes genricos que puedan ser desarrollados de forma separada y combinados arbitrariamente, sujetos a interfaces bien definidas La base de la interrelacin entre abstracciones genricas de datos y abstracciones de algoritmos en la programacin genrica son los iteradores
12
Tema 4: Genericidad
3.2 Definicin
La Programacin Genrica se define como un rea que tiene que ver con tratar de encontrar representaciones genricas de algoritmos eficientes, estructuras de datos y otros conceptos de software y con su organizacin sistemtica. El objetivo es expresar algoritmos junto con las estructuras de datos en una forma ampliamente adaptable e interoperable que permita su uso directo en la construccin de software. Las ideas claves incluyen expresar algoritmos concretos a un nivel lo ms general posible sin perder eficiencia, es decir, que cuando la forma general se instancie para obtener los casos concretos resulten algoritmos tan eficientes como los originales [Musser and Stepanov, 1998]
13
4. Genericidad en C++
14
Tema 4: Genericidad
4.1 Plantillas
Introduccin
Las plantillas proporcionan una forma de representar una amplia gama de conceptos generales y formas sencillas de combinarlos Las plantillas ofrecen soporte directo a la programacin genrica El mecanismo de plantillas de C++ permite que un tipo sea un parmetro en la definicin de una clase o de una funcin Las plantillas son una de las caractersticas de C++ que favorecen la reutilizacin
4.2 Plantillas
Plantillas de funcin
En C++ se utiliza la sobrecarga de funciones para llevar a cabo operaciones similares sobre diferentes tipos Si las operaciones son idnticas para cada tipo, es ms conveniente el uso de plantillas de funcin Se define una nica plantilla de funcin y, basndose en los tipos de los argumentos ofrecidos en la llamada a la funcin, el compilador generar el cdigo objeto de tantas funciones como necesite para manejar cada llamada de forma adecuada Toda plantilla de funcin comienza con la palabra reservada template seguida de una lista de parmetros formales para la plantilla de funcin, encerrada entre parntesis angulares
Cada parmetro formal representa un tipo, estando precedido de la palabra reservada class
template< class T > template< class TipoElemento > template< class TipoBorde, class TipoRelleno > Departamento de Informtica y Automtica - Universidad de Salamanca 16
Tema 4: Genericidad
4.2 Plantillas
#include <iostream.h> template< class T > void ImprimeVector(const T *vector, const int eltos); void main(void) { const int l1=5, l2=7, l3=9; int m1[l1]={1,2,3,4,5}; double m2[l2]={9.0,19.3,1,-1.83,7.2,-43.03,1.8}; char m3[l3]="GARABATO"; cout << "El contenido del vector m1 es: " << endl; ImprimeVector(m1, l1); cout << "El contenido del vector m2 es: " << endl; ImprimeVector(m2, l2); cout << "El contenido del vector m3 es: " << endl; ImprimeVector(m3, l3); } template< class T > void ImprimeVector(const T *vector, const int eltos) { for (register int i=0; i<eltos; ) cout << *(vector+i++) << " "; cout << endl; }
El contenido del vector m1 es: 12345 El contenido del vector m2 es: 9 19.3 1 -1.83 7.2 -43.03 1.8 El contenido del vector m3 es: GARABATO 17
4.2 Plantillas
Reglas para la resolucin de la sobrecarga en las plantillas de funcin [Stroustrup, 1997]
1) Encontrar el conjunto de especializaciones de plantillas de funcin que va a tomar parte en la resolucin de la sobrecarga. Hacerlo considerando cada plantilla de funcin y decidiendo qu argumentos de plantilla, si los hay, se usaran si no estuvieran dentro del mbito de otras plantillas de funcin o funciones del mismo nombre Si se puede llamar a dos funciones de plantilla y una es ms especializada que la otra, hay que tener en cuenta slo la funcin de plantilla ms especializada en los pasos siguientes Hacer la resolucin de la sobrecarga para este conjunto de funciones, ms las posibles funciones ordinarias. Si se ha determinado un argumento de funcin de plantilla por deduccin de argumentos de plantilla, a ese argumento no se le pueden aplicar tambin promociones, conversiones estndar o conversiones definidas por el usuario Si una funcin y una especializacin son concordancias igualmente buenas, se prefiere la funcin Si no se encuentra concordancia la llamada es un error. Si se termina con dos concordancias igualmente buenas, la llamada es ambigua y es un error
18
2)
3)
4) 5)
Tema 4: Genericidad
4.2 Plantillas
template< class T > T sqrt(T); template< class T > complex<T> sqrt(complex<T>); double sqrt(double); void f (complex<double> z) { sqrt(2); sqrt(2.0); sqrt(z); }
- Por (3) se prefiere sqrt<int>(int) a sqrt(double) por ser una concordancia exacta - Por (4) se prefiere sqrt(double) a sqrt<double>(double)
- Por (1) sqrt<double>(complex<double>) y sqrt<complex<double>>(complex<double>) sean candidatas - Por (2) se prefiere sqrt<complex<double>>(complex<double>) a sqrt<double>(complex<double>) : Toda llamada que concuerde con sqrt(<complex<T>) concuerda tambin con sqrt(T)
4.2 Plantillas
#include <iostream.h> template< class T > T max(T,T); void main(void) { const int s=6; cout << max(1,2) << endl; cout << max('a','b') << endl; cout << max(34.7,6.9) << endl; cout << max(4,s) << endl; cout << max('a', 1) << endl; // Error -> max<int>('a', 1) cout << max(2.7, 43) << endl; // Error -> max<double>(2.7, 43) } template< class T > T max(T a, T b) { if (a > b) return a; return b; }
20
Tema 4: Genericidad
4.2 Plantillas
Plantillas de clase
Las plantillas de clase favorecen la reusabilidad permitiendo versiones especficas con respecto al instanciar clases genricas Se denominan tipos paramtricos porque requieren uno o ms tipos como parmetros para instanciar sus parmetros genricos Slo se define una plantilla de clase, cada vez que se necesita una nueva versin, especfica para un tipo, se instancia y el compilador genera el cdigo adecuado La definicin de una plantilla de clase es como la definicin de una clase convencional, precedida por la especificacin de los parmetros genricos:
template< class T >
El proceso de generar una declaracin de clase a partir de una clase de plantilla y un argumento de plantilla se denomina instanciacin de plantilla Una versin de una plantilla para un argumento de plantilla concreto se denomina especializacin
21
4.2 Plantillas
Plantillas de clase Una plantilla puede tomar parmetros de tipo y parmetros de tipos ordinarios Pueden tomar varios argumentos La herencia con relacin a las plantillas puede ocurrir de las siguientes formas
Una clase plantilla puede derivarse de otra clase plantilla Una plantilla puede derivarse de una clase normal
Funciones (globales o miembros) y clases enteras pueden declararse como amigas de una clase paramtrica
Las funciones amigas pueden ser plantillas de funciones, aunque no es obligatorio
22
Tema 4: Genericidad
4.2 Plantillas
Plantillas de clase
template< class T > class Pila { int cima; int tamano; T *espacio; bool estaVacia() const {return cima==-1;} bool estaLlena() const {return cima==tamano-1;} public: Pila(int); ~Pila() {delete [] espacio;} bool poner (const T&); bool quitar(T&); int elementos(); };
23
4.2 Plantillas
Plantillas de clase
// Constructor por defecto template< class T > Pila< T >::Pila(int t){ tamano = t > 0 ? t : 10; cima=-1; espacio = new T[tamano]; } template< class T > bool Pila< T >::poner(const T &valor) { if ( !estaLlena() ) { espacio[++cima]=valor; return true; } return false; } template< class T > bool Pila< T >::quitar(T &retorno) { if ( !estaVacia() ) { retorno = espacio[cima--]; return true; } return false; } template< class T > int Pila< T >::elementos() {return cima+1;}
24
Tema 4: Genericidad
4.2 Plantillas
Plantillas de clase
void main() { Pila< int > intPila(10); int i=100; cout << "Llenando la pila de enteros..." << endl; while( intPila.poner(i++) ); cout << "Pila llena. Hay " << intPila.elementos() << " nmeros en la pila" << endl; while( intPila.quitar(i) ) cout << i << endl; cout << "Llenando la pila de dobles..." << endl; Pila< double > doublePila(5); double x=100.5; while( doublePila.poner(x+=.75) ); cout << "Pila llena. Hay " << doublePila.elementos() << " nmeros en la pila" << endl; while( doublePila.quitar(x) ) cout << x << endl; } Departamento de Informtica y Automtica - Universidad de Salamanca 25
4.2 Plantillas
Plantillas de clase
template< class T, const int tamano > class Pila { int cima; T *espacio; bool estaVacia() const {return cima==-1;} bool estaLlena() const {return cima==tamano-1;} public: Pila(); ~Pila() {delete [] espacio;} bool poner (const T&); bool quitar(T&); int elementos(); };
26
Tema 4: Genericidad
4.2 Plantillas
Plantillas de clase
// Constructor por defecto template< class T, const int tamano > Pila< T, tamano >::Pila(){ cima=-1; espacio = new T[tamano]; } template< class T, const int tamano > bool Pila< T, tamano >::poner(const T &valor) { if ( !estaLlena() ) { espacio[++cima]=valor; return true; } return false; } template< class T, const int tamano > bool Pila< T, tamano >::quitar(T &retorno) { if ( !estaVacia() ) { retorno = espacio[cima--]; return true; } return false; } template< class T, const int tamano > int Pila< T, tamano >::elementos() {return cima+1;}
27
4.2 Plantillas
Plantillas de clase
void main() { Pila< int, 10 > intPila; int i=100; while( intPila.poner(i++) ); cout << "Llenando pila de enteros..." << endl; cout << "Pila llena. Hay " << intPila.elementos() << " nmeros en la pila" << endl; while( intPila.quitar(i) ) cout << i << endl; Pila< double, 5 > doublePila; double x=100.5; while( doublePila.poner(x+=.75) ); cout << "Llenando la pila de dobles..." << endl; cout << "Pila llena. Hay " << doublePila.elementos() << " nmeros en la pila" << endl; while( doublePila.quitar(x) ) cout << x << endl; } Departamento de Informtica y Automtica - Universidad de Salamanca 28
Tema 4: Genericidad
Introduccin STL (Standard Template Library Biblioteca Estndar de Plantillas) [Stepanov and Lee, 1994]
Biblioteca de clases genricas para C++ Desarrollada por Alexander Stepanov y Meng Lee en los laboratorios de Hewlett Packard (Palo Alto California, 1994) Integrada en el estndar ANSI C++ [X3J16/WG21, 1996] Antecedentes
Biblioteca de funciones genricas para Ada [Musser and Stepanov, 1987] Incorporacin de A. Stepanov a Hewlett Packard (1988), trabajando en algoritmos genricos Biblioteca basada en algoritmos genricos, antecedente de STL [Musser and Stepanov, 1994]
4.3 STL
Introduccin El cdigo fuente de la biblioteca STL es de una gran calidad, no haciendo uso de la herencia STL es una biblioteca de componentes, que pueden ser de los siguientes tipos
Algoritmo: Procedimientos computacionales que pueden trabajar sobre diferentes contenedores Contenedor: Objeto que puede contener y manejar objetos Iterador: Abstraccin de un algoritmo de acceso a contenedores, pudiendo trabajar sobre diferentes contenedores Objeto funcin: Clase que tiene definida la funcin operator() Adaptador: Encapsula un componente para ofrecer otra interfaz
4.3 STL
30
Tema 4: Genericidad
Contenedores
Uno de los tipos ms til de clases son las clases contenedoras, que son clases que almacenan objetos de cualquier otro tipo [Stroustrup, 1997]
Controlan las operaciones de construccin, destruccin, insercin y borrado de los objetos contenidos En STL los contenedores se diferencian en la forma en que los elementos se organizan y cmo se ordenan utilizando alguna clave Se distinguen entre Contenedores Secuenciales y Contenedores Asociativos Un contenedor secuencial es un tipo de contenedor que organiza un conjunto finito de objetos, todos del mismo tipo, en una disposicin estrictamente lineal
Tres tipos bsicos: vectores, listas y colas
4.3 STL
Un contenedor asociativo ofrece la facilidad para la rpida recuperacin de los datos basndose en claves. Los elementos estn ordenados y se posibilita la bsqueda binaria para la recuperacin de los datos
Cuatro tipos bsicos: conjuntos, mapas, multiconjuntos y multimapas
31
Contenedores Vector
Es contenedor secuencial que soporta iteradores de acceso aleatorio La gestin del almacenamiento es manejada automticamente Para la utilizacin de vectores se debe utilizar el fichero cabecera vector.h STL se abstrae de los modelos especficos de memoria que se utilizan mediante el concepto de allocator. Toda la informacin sobre el modelo de memoria utilizado se encapsula en la clase Allocator. Cada contenedor est parametrizado de forma que un allocator permite que la implementacin no se cambie cuando se cambia el modelo de memoria
template <class T, template <class U> class Allocator = allocator> class vector { ... };
4.3 STL
32
Tema 4: Genericidad
Contenedores Vector
En la mayora de las implementaciones un vector almacena los elementos en un espacio contiguo de memoria, que permite un acceso indexado rpido Cuando el espacio reservado inicialmente para el vector se excede, sus elementos son copiados en un nuevo espacio de memoria mayor, siendo el primer espacio liberado Insertar un elemento en un vector es proporcional a la distancia entre el punto de insercin y el final del vector La insercin de varios elementos con una sola llamada de insercin es proporcional a la suma del nmero de elementos ms la distancia al final del vector. Esto es, es ms rpido insertar varios elementos en la mitad del vector que hacerlo de uno en uno Insertar elementos en cualquier lugar, excepto al final del vector, es lento, por lo que no se debera utilizar en sistemas donde esta operacin es comn (siendo mejor solucin para estos casos una lista o una cola) Si una insercin conlleva redimensionamiento, todos los iteradores y referencias se invalidan; en otro caso slo los iteradores y referencias despus del punto de insercin se invalidan Borrar un elemento invalida todos los iteradores y referencias despus del punto de borrado
33
4.3 STL
Contenedores Vector
template <class T, template <class U> class Allocator = allocator> class vector { public: // typedefs: typedef iterator; typedef const_iterator; typedef Allocator<T>::pointer pointer; typedef Allocator<T>::reference reference; typedef Allocator<T>::const_reference const_reference; typedef size_type; typedef difference_type; typedef T value_type; typedef reverse_iterator; typedef const_reverse_iterator; // allocation/deallocation: vector(); vector(size_type n, const T& value = T()); vector(const vector<T, Allocator>& x); template <class InputIterator> vector(InputIterator first, InputIterator last); ~vector(); vector<T, Allocator>& operator=(const vector<T, Allocator>& x); void reserve(size_type n); void swap(vector<T, Allocator>& x); // accessors: iterator begin(); const_iterator begin() const; iterator end(); const_iterator end() const; reverse_iterator rbegin(); const_reverse_iterator rbegin(); reverse_iterator rend(); const_reverse_iterator rend(); size_type size() const; size_type max_size() const; size_type capacity() const; bool empty() const; reference operator[](size_type n); const_reference operator[](size_type n) const; reference front(); const_reference front() const; reference back(); const_reference back() const; // insert/erase: void push_back(const T& x); iterator insert(iterator position, const T& x = T()); void insert(iterator position, size_type n, const T& x); template <class InputIterator> void insert(iterator position, InputIterator first, InputIterator last); void pop_back(); void erase(iterator position); void erase(iterator first, iterator last); };
4.3 STL
34
Tema 4: Genericidad
Vector
Constructores
Contenedores
4.3 STL
vector (size_type n)
Crea un vector capaz de contener n elementos
vector (size_type n, const T& valor)

Crea un vector que contiene n copias de valor
vector (const T* primero, const T* ltimo)

Crea un vector que contiene copia de todos los elementos en el rango [primero, ltimo)
Operaciones
T& back ( )
Retorna una referencia al ltimo elemento
T& front ( )
Retorna una referencia al primer elemento
T& operator [ ] (int ndice)

Retorna una referencia al n-simo elemento indexado
void push_back (const T& valor)

Aade valor al final del vector, expandiendo el almacenamiento para alojar el nuevo elemento si fuera necesario
void pop_back ( )
Elimina el ltimo elemento
Contenedores Vector
Operaciones
void erase (iterator pos)
Elimina el elemento que se encuentra en pos
4.3 STL
void erase (iterator primero, iterator ltimo)

Elimina los elementos en el rango [primero, ltimo)
iterator insert (iterator pos, const T& valor)

Inserta una copia de valor en la posicin pos
void insert (iterator pos, size_type n, const T& valor)

Inserta n copias de valor a partir de pos
void insert (iterator pos, const T* primero, const T* ltimo)

Inserta copia de los elementos en el rango [primero, ltimo) a partir de pos
size_type capacity ( ) const

Retorna el nmero de elementos que se pueden contener en un vector sin volver a reservar memoria
void reserve (size_type n)

Reserva suficiente espacio para alojar n elementos. Esta operacin no cambia el valor devuelto por size()
Tema 4: Genericidad
Vector
#include <vector.h> #include <iostream.h> void main() { int i; vector<int> v; vector<double> d(4); vector<double>::iterator di;
Contenedores
4.3 STL
cout << "Tamao del vector de enteros: " << v.size() << endl; cout << "Tamao mximo del vector de enteros: " << v.max_size() << endl; cout << "Elementos que se pueden contener sin reservar ms memoria: " << v.capacity() << endl; cout << "Tamao del vector de dobles: " << d.size() << endl; cout << "Tamao mximo del vector de dobles: " << d.max_size() << endl; cout << "Elementos que se pueden contener sin reservar ms memoria: " << d.capacity() << endl; // Insercin al final del vector enteros v.push_back(1); v.push_back(2); v.push_back(3); // Valores del vector de dobles d[0] = 0.45; d[1] = .001; d[2] = 3.1416; d[3] = -3.3; // Insercin en el vector de dobles d.insert(d.begin(), -900.8); d.insert(d.begin()+2, -999.8); // Recorrido de los vectores cout << "Tamao del vector de enteros: " << v.size() << endl; cout << "Los elementos del vector de enteros son:" << endl; for (i=0; i<v.size(); i++) cout << "v[" << i <<"] = " << v[i] << endl; cout << "Tamao del vector de dobles: " << d.size() << endl; cout << "Los elementos del vector de dobles son:" << endl; for (i=0, di=d.begin(); di!=d.end(); di++, i++) cout << "d[" << i <<"] = " << *di << endl; }
Tamao del vector de enteros: 0 Tamao mximo del vector de enteros: 1073741823 Elementos que se pueden contener sin reservar ms memoria: 0 Tamao del vector de dobles: 4 Tamao mximo del vector de dobles: 536870911 Elementos que se pueden contener sin reservar ms memoria: 4 Tamao del vector de enteros: 3 Los elementos del vector de enteros son: v[0] = 1 v[1] = 2 v[2] = 3 Tamao del vector de dobles: 6 Los elementos del vector de dobles son: d[0] = -900.8 d[1] = 0.45 d[2] = -999.8 d[3] = 0.001 d[4] = 3.1416 d[5] = -3.3
37
Contenedores Vector
#include<iostream.h> #include<vector.h> template<class T> void MuestraVector(vector<T>&); void main() { int vector_int [] = {1, 2, 3, 4, 5}; vector<int> v (vector_int, vector_int+5); MuestraVector(v); v.erase(v.begin()); //Borra el primer elemento MuestraVector(v); v.erase(v.end()-1); //Borra el primer elemento MuestraVector(v);
4.3 STL
v[0] v[1] v[2] v[3] v[4] v[0] v[1] v[2] v[3]
= = = = = = = = =
1 2 3 4 5 2 3 4 5
v[0] = 2 v[1] = 3 v[2] = 4 v[0] = 2 v[1] = 4
//void erase(iterator first, iterator last) - Borra rango [first, last) v.erase(v.begin()+1, v.end()-1);//Borra todos menos el primero y el ltimo MuestraVector(v); } template<class T> void MuestraVector(vector<T> &v) { for (int i=0; i<v.size(); i++) cout << "v["<<i<<"] = " << v[i] << endl; cout << endl; }
38
Tema 4: Genericidad
Contenedores Vector
#include <vector.h> #include <iostream.h> void main() { vector<int> v(3, 1); cout << "capacidad de v = v.reserve(100); cout << "capacidad de v = v.push_back(5); for (int i=0; i<v.size(); cout << "v["<<i<<"] = }
4.3 STL
" << v.capacity() << endl; " << v.capacity() << endl; i++) " << v[i] << endl;
capacidad de v = 3 capacidad de v = 100 v[0] = 1 v[1] = 1 v[2] = 1 v[3] = 5
39
Deque

Contenedores
4.3 STL
Una cola (deque) es un contenedor secuencial que est optimizado para accesos basados en ndices, as como para una eficiente insercin en cualquiera de sus dos extremos Presenta tiempo constante para las operaciones de insercin y borrado tanto al comienzo como al final de la misma Las operaciones de insercin y borrado en el medio de la cola requieren un tiempo proporcional a la posicin del elemento Si la insercin causa redimensionamiento de memoria, todos los iteradores y referencias se invalidan; en otro caso, los iteradores y referencias slo se invalidan si el elemento no se inserta en los extremos Si se borra el primer o el ltimo elemento, todos los iteradores y referencias son vlidos; en cualquier otro caso todos los iteradores y referencias son invalidados La gestin del almacenamiento se hace de forma automtica Para la utilizacin de colas debe emplearse el fichero deque.h Las colas son tiles en circunstancias en que el orden, el almacenamiento compacto y la insercin rpida en los extremos son importantes. Es una estructura idnea para implementar estructuras FIFO Si se requiere insercin rpida en la mitad de la estructura secuencial, debe considerarse el empleo de una lista
40
Tema 4: Genericidad
Deque
Contenedores
iterator begin(); const_iterator begin() const; iterator end(); const_iterator end() const; reverse_iterator rbegin(); const_reverse_iterator rbegin(); reverse_iterator rend(); const_reverse_iterator rend(); size_type size() const; size_type max_size() const; bool empty() const; reference operator[](size_type n); const_reference operator[](size_type n) const; reference front(); const_reference front() const; reference back(); const_reference back() const; void push_front(const T& x); void push_back(const T& x); iterator insert(iterator position, const T& x = T()); void insert (iterator position, size_type n, const T& x); template <class InputIterator> void insert (iterator position, InputIterator first, InputIterator last); void pop_front(); void pop_back(); void erase(iterator position); void erase(iterator first, iterator last);
4.3 STL
template <class T, template <class U> class Allocator = allocator> // accessors: class deque { public: // typedefs: typedef iterator; typedef const_iterator; typedef Allocator<T>::pointer pointer; ypedef Allocator<T>::reference reference; typedef Allocator<T>::const_reference const_reference; typedef size_type; typedef difference_type; typedef T value_type; typedef reverse_iterator; typedef const_reverse_iterator; // allocation/deallocation: deque(); deque(size_type n, const T& value = T()); deque(const deque<T, Allocator>& x); template <class InputIterator> // insert/erase: deque(InputIterator first, InputIterator last); ~deque(); deque<T, Allocator>& operator=(const deque<T, Allocator>& x); void swap(deque<T, Allocator>& x);
};
41
Contenedores Deque
Tiene prcticamente la misma interfaz que el vector, se destacan las siguientes diferencias
void insert (iterator pos, const iterator primero, const iterator ltimo)
Inserta copias de los elementos en el rango [primero, ltimo)
4.3 STL
void pop ( )
Elimina el primer elemento
void push_front (const T& valor)

Inserta una copia de valor al principio del contenedor
42
Tema 4: Genericidad
Deque
#include <deque.h> #include <iostream.h>
Contenedores
4.3 STL
template<class T> void MuestraDeque(deque<T> &); void main() { deque<char> d; d.push_back('4'); d.push_back('a'); d.push_back('%'); d.push_front('1'); MuestraDeque(d); d.pop_front(); d[1]='O'; MuestraDeque(d); } template<class T> void MuestraDeque(deque<T> &d) { for (int i=0; i<d.size(); i++) cout << "d["<<i<<"] = " << d[i] << endl; cout << endl; }
d[0] d[1] d[2] d[3]
= = = =
1 4 a %
d[0] = 4 d[1] = O d[2] = %
43
List
Contenedores
4.3 STL
Una lista es un contenedor secuencial que soporta iteradores bidireccionales y tiene un tiempo constante para insertar y borrar elementos cualquiera que sea su posicin en la secuencia El almacenamiento es gestionado de forma automtica A diferencia de los vectores y colas, el acceso aleatorio rpido a los elementos no est permitido La insercin de mltiples elementos en la lista es proporcional al nmero de elementos insertados La insercin no afecta a los iteradores o las referencias El borrado invalida los iteradores y las referencias a los elementos borrados Para la utilizacin de listas debe emplearse el fichero list.h Las listas tienen la interfaz ms completa de todos los contenedores secuenciales. Existen funciones para mover entre listas, eliminar, filtrar, mezclar y ordenar
44
Tema 4: Genericidad
List
Contenedores
4.3 STL
const_reverse_iterator rend(); template <class T, template <class U> class Allocator = allocator> bool empty() const; class list { size_type size() const; public: size_type max_size() const; // typedefs: reference front(); ypedef iterator; const_reference front() const; typedef const_iterator; reference back(); typedef Allocator<T>::pointer pointer; const_reference back() const; typedef Allocator<T>::reference reference; // insert/erase: typedef Allocator<T>::const_reference const_reference; void push_front(const T& x); typedef size_type; void push_back(const T& x); typedef difference_type; iterator insert(iterator position, const T& x = T()); typedef T value_type; void insert(iterator position, size_type n, const T& x); typedef reverse_iterator; template <class InputIterator> typedef const_reverse_iterator; void insert(iterator position, InputIterator first, InputIterator last); // allocation/deallocation: void pop_front(); list(); void pop_back(); list(size_type n, const T& value = T()); void erase(iterator position); template <class InputIterator> void erase(iterator first, iterator last); list(InputIterator first, InputIterator last); // special mutative operations on list: list(const list<T, Allocator>& x); void splice(iterator position, list<T, Allocator>& x); ~list(); void splice(iterator position, list<T, Allocator>& x, iterator i); list<T, Allocator>& operator=(const list<T, Allocator>& x); void splice(iterator position, list<T, Allocator>& x, iterator first, void swap(list<T, Allocator>& x); iterator last); // accessors: void remove(const T& value); iterator begin(); template <class Predicate> void remove_if(Predicate pred); const_iterator begin() const; void unique(); iterator end(); template <class BinaryPredicate> void unique(BinaryPredicate const_iterator end() const; binary_pred); reverse_iterator rbegin(); void merge(list<T, Allocator>& x); const_reverse_iterator rbegin(); template <class Compare> void merge(list<T, Allocator>& x, Compare reverse_iterator rend(); comp); void reverse(); void sort(); template <class Compare> void sort(Compare comp); };
45
List
Funciones
Contenedores
void splice (iterator pos, list<T>& lista)
Mueve todos los elementos de lista y los inserta despus de pos
4.3 STL
void splice (iterator pos, list<T>& lista, iterator inicio)

Mueve los elementos de lista desde la posicin inicio y los inserta a partir de la posicin pos
void splice (iterator pos, list<T>& lista iterator primero, iterator ltimo)
Mueve los elementos de lista en el rango [primero, ltimo) y los inserta a partir de la posicin pos. Esta funcin permite que las listas origen y destino sean las mimas
void remove (const T& valor)

Elimina todos los elementos con valor igual a valor
void reverse ( )
Invierte el orden de los elementos. La complejidad es O(N)
void unique ( )
Reemplaza todas las secuencias de un elemento por una sola ocurrencia de dicho elemento
void sort ( )
Ordena los elementos utilizando el operador <. La complejidad es O(NlogN)
void merge (const list<T> lista)

Mueve los elementos de lista y los coloca ordenados con respecto al operador <. Se asume que ambas listas estn ordenadas con respecto al operador <. Departamento de Informtica y Automtica - Universidad de Salamanca 46
Tema 4: Genericidad
List
#include <list.h> #include <iostream.h>
Contenedores
4.3 STL
void main() { int array1 [] = {9, 16, 89}; int array2 [] = {3, 0}; list<int> lis1(array1, array1+3); list<int> lis2(array2, array2+2); lis1.splice(lis1.begin(), lis2); list<int>::iterator i=lis1.begin(); while( i!=lis1.end() ) cout << *i++ << endl; }
3 0 9 16 89
47
List
Contenedores
4.3 STL
void main() { int array1 [] = {1, 2}; int array2 [] = {3, 4}; list<int> lis1 (array1, array1+2); list<int> lis2 (array2, array2+2); list<int>::iterator i=lis1.begin(); i++; lis1.splice( i, lis2, lis2.begin(), lis2.end() ); i=lis1.begin(); while( i!=lis1.end() ) 1 cout << *i++ << endl; 3 }
4 2
48
Tema 4: Genericidad
List
Contenedores
4.3 STL
void main() { char array [] = {'O', 'B', 'J', 'E', 'T', 'O', 'S','S','S'}; list<char> cad (array, array+9); list<char>::iterator i; cout << "Original: "; for(i=cad.begin(); i!=cad.end(); i++) cout << *i; cout << endl << "Al revs: "; Original: OBJETOSSS cad.reverse(); Al revs: SSSOTEJBO for(i=cad.begin(); i!=cad.end(); i++) cout << *i; Sin 'J': SSSOTEBO cad.remove('J'); Sin letras repetidas: SOTEBO cout << endl << "Sin 'J': "; Ordenada: BEOOST for(i=cad.begin(); i!=cad.end(); i++) cout << *i; cad.unique(); cout << endl << "Sin letras repetidas en secuencia: "; for(i=cad.begin(); i!=cad.end(); i++) cout << *i; cad.sort(); cout << endl << "Ordenada: "; for(i=cad.begin(); i!=cad.end(); i++) cout << *i; cout << endl; }
49
Contenedores List
#include <list.h> #include <iostream.h> void main() { int array1 [] = {1,3,5,7,9}; int array2 [] = {2,4,6,8}; list<int> lis1 (array1, array1+5); list<int> lis2 (array2, array2+4); lis1.merge(lis2); list<int>::iterator i=lis1.begin(); while( i !=lis1.end() ) cout << *i++ << " "; cout << endl; cout << endl << "Tamao de lis2: " << lis2.size() << endl; } 1 2 3 4 5 6 7 8 9 Tamao de lis2: 0 Departamento de Informtica y Automtica - Universidad de Salamanca 50
4.3 STL
Tema 4: Genericidad
Contenedores Multiset
Un multiconjunto es un tipo de contenedor asociativo que soporta claves iguales (posiblemente contenga mltiples copias del mismo valor de la clave) Ofrece una rpida recuperacin de las claves Se utilizan cuando se necesita una rpida recuperacin, no se requiere una localizacin indexada y los duplicados estn permitidos La insercin no afecta a los iteradores o a la referencias El borrado invalida los iteradores y las referencias a los elementos borrados Para la utilizacin de multiconjuntos debe emplearse el fichero cabecera multiset.h
51
4.3 STL
Contenedores Multiset
template <class Key, class Compare = less<Key>, template <class U> class Allocator = allocator> class multiset { public: // typedefs: typedef Key key_type; typedef Key value_type; typedef Allocator<Key>::pointer pointer; typedef Allocator<Key>::reference reference; typedef Allocator<Key>::const_reference const_reference; typedef Compare key_compare; typedef Compare value_compare; typedef iterator; typedef iterator const_iterator; typedef size_type; typedef difference_type; typedef reverse_iterator; typedef const_reverse_iterator; // allocation/deallocation: multiset(const Compare& comp = Compare()); template <class InputIterator> multiset(InputIterator first, InputIterator last, const Compare& comp = Compare()); multiset(const multiset<Key, Compare, Allocator>& x); ~multiset(); multiset<Key, Compare, Allocator>& operator=(const multiset<Key, Compare, Allocator>& x); void swap(multiset<Key, Compare, Allocator>& x); // accessors: key_compare key_comp() const; value_compare value_comp() const; iterator begin() const; iterator end() const; reverse_iterator rbegin(); reverse_iterator rend(); bool empty() const; size_type size() const; size_type max_size() const; // insert/erase: iterator insert(const value_type& x); iterator insert(iterator position, const value_type& x); template <class InputIterator> void insert(InputIterator first, InputIterator last); void erase(iterator position); size_type erase(const key_type& x); void erase(iterator first, iterator last); // multiset operations: iterator find(const key_type& x) const; size_type count(const key_type& x) const; iterator lower_bound(const key_type& x) const; iterator upper_bound(const key_type& x) const; pair<iterator, iterator> equal_range(const key_type& x) const; };
4.3 STL
52
Tema 4: Genericidad
Multiset
Constructores
multiset( )
Contenedores
Construye un multiconjunto vaco que ordena los elementos utilizando la funcin de comparacin especificada cuando la plantilla fue instanciada Construye un multiconjunto que contiene copia de los elementos en el rango [primero, ltimo), utilizando la funcin de comparacin especificada cuando la plantilla fue instanciada Construye un multiconjunto vaco que ordena los elementos utilizando la funcin comparar
4.3 STL
multiset (const Key* primero, const Key* ltimo)
multiset (const Compare& comparar)
Funciones
size_type count(const Key& clave)
Retorna el nmero de elementos que coinciden con clave Borra todos los elementos que coinciden con clave y retorna el nmero de elementos borrados Si existe un elemento que coincide con clave, retorna un iterador posicionado en dicho elemento, en otro caso retorna un iterador posicionado en end() Inserta una copia de clave y retorna un iterador posicionado en el nuevo elemento Inserta copias de los elementos en el rango [primero, ltimo) Retorna un iterador posicionado en la primera posicin en la que clave puede insertarse sin violar el criterio de orden. Si no se encuentra una posicin, el iterador se posiciona en end() Retorna un iterador posicionado en la ltima posicin en la que clave puede insertarse sin violar el criterio de orden. Si no se encuentra una posicin, el iterador se posiciona en end() Retorna un par de iteradores cuyo primer elemento es igual a lower_bound() y el segundo elemento es igual a upper_bound()
size_type erase(const Key& clave) iterator find(const Key& clave) const iterator insert(const Key& clave)

void insert(const Key* primero, const Key* ltimo) iterator lower_bound(const Key& clave) const iterator upper_bound(const Key& clave) const
pair <const_iterator, const iterator> equal_range (const Key& valor) const
53
Multiset
Contenedores
4.3 STL
#include<iostream.h> #include<multiset.h> template<class T> void Buscar(multiset<T, greater<T> >&, T); void main() { typedef multiset< int, greater<int> > mset; // Construccin de un multiset vaco mset ms; cout << "count (42) = " << ms.count(42) << endl; ms.insert(42); cout << "count (42) = " << ms.count(42) << endl; ms.insert(41); ms.insert(42); ms.insert(35); ms.insert(65); cout << "count (42) = " << ms.count(42) << endl; Buscar(ms, 43); Buscar(ms, 41); mset::iterator i; for (i=ms.begin(); i!=ms.end();) cout << *i++ << " "; cout << endl << endl; // Borrar todos los 42 int cuenta = ms.erase(42); cout << "Borradas " << cuenta << " instancias" << endl; for (i=ms.begin(); i!=ms.end();) cout << *i++ << " "; cout << endl << endl; } template<class T> void Buscar(multiset<T, greater<T> > &ms, T clave) { multiset<T, greater<T> >::iterator i = ms.find(clave); if ( i==ms.end() ) cout << "No se ha encontrado " << clave << endl; else cout << *i << " est presente" << endl; }
count (42) = 0 count (42) = 1 count (42) = 2 No se ha encontrado 43 41 est presente 65 42 42 41 35 Borradas 2 instancias 65 41 35
54
Tema 4: Genericidad
Multiset
#include<iostream.h> #include<multiset.h> #include<string.h>
Contenedores
4.3 STL
class less_s { public: bool operator () (const char* cad1, const char* cad2) const { return strcmp (cad1, cad2) < 0; } }; void main() { typedef multiset <char*, less_s> mset; char* nombres[] = {"Pepe", "Ana", "Luis", "Alejandro", "Mar"}; mset ms; ms.insert(nombres, nombres+5); for(mset::iterator i = ms.begin(); i!=ms.end();) cout << *i++ << endl; } Alejandro Ana Luis Mar Pepe 55
Multiset
#include <multiset.h> #include <iostream.h>
Contenedores
4.3 STL
void main() { int array [] = {3,5,5,7,1,2,3,1,9,6,3,7}; typedef multiset<int, less<int> > mset; mset ms(array, array+12); mset::iterator i; for (i=ms.begin(); i!=ms.end(); i++) cout << *i << " "; cout << endl << endl;
1 1 2 3 3 3 5 5 6 7 7 9 Lower Upper Ahora Lower Upper Bound: 3 Bound: 5 con equal_range()... Bound: 3 Bound: 5
// Posicin del primer elemento que no es menor que 3 i=ms.lower_bound(3); cout << "Lower Bound: " << *i << endl; // Posicin del primer elemento que es mayor que 3 i=ms.upper_bound(3); cout << "Upper Bound: " << *i << endl; cout << "Ahora con equal_range()..." << endl; pair<mset::const_iterator, mset::const_iterator> p = ms.equal_range(3); cout << "Lower Bound: " << *(p.first) << endl; cout << "Upper Bound: " << *(p.second) << endl; }
56
Tema 4: Genericidad
Multiset
#include<multiset.h> #include<iostream.h>
Contenedores
4.3 STL
bool menor_que(int a, int b) { return a < b; } bool mayor_que(int a, int b) { return a > b; } void main() { int array [] = {9, 1, 7, 9, 8, 2, 1}; typedef pointer_to_binary_function<int, int, bool> tipoFn; typedef multiset<int, tipoFn> mset; tipoFn fn1 (menor_que); mset ms1(array, array+7, fn1); cout << "Utilizando menor_que..." << endl; mset::iterator i=ms1.begin(); for (; i!=ms1.end(); i++) cout << *i << " "; tipoFn fn2 (mayor_que); mset ms2(array, array+7, fn2); cout << endl << "Utilizando mayor_que..." << endl; for (i=ms2.begin(); i!=ms2.end(); i++) cout << *i << " ";
Utilizando menor_que... 1 1 2 7 8 9 9 Utilizando mayor_que... 9 9 8 7 2 1 1
57
Set

Contenedores
El comportamiento de los conjuntos es idntico al de los multiconjuntos, a excepcin de que no permite elementos repetidos Se utilizan cuando se necesita una rpida recuperacin, no se requiere una localizacin indexada y los duplicados no estn permitidos Las inserciones no afectan a los iteradores o referencias Las eliminaciones slo invalidan los iteradores y las referencias de los elementos borrados La principal diferencia entre un conjunto y multiconjunto es que el conjunto no puede tener repetidos, los intentos de aadir un elemento repetido se ignoran La funcin insert() retorna un objeto pair que contiene el resultado de la operacin
pair <const_iterator, bool> insert (const Key& clave)
Si el conjunto no contiene el elemento clave, se inserta una copia de la clave y retorna un objeto pair cuyo primer elemento es un iterador posicionado en el nuevo elemento y el segundo es true. Si ya se contiene ese elemento retorna un objeto pair cuyo primer elemento es un iterador posicionado en el elemento existente y el segundo false
4.3 STL
Para la utilizacin de multiconjuntos debe emplearse el fichero cabecera set.h

58
Tema 4: Genericidad
Set
Contenedores
// accessors: key_compare key_comp() const; value_compare value_comp() const; iterator begin() const; iterator end() const; reverse_iterator rbegin() const; reverse_iterator rend() const; bool empty() const; size_type size() const; size_type max_size() const; // insert/erase: pair<iterator, bool> insert(const value_type& x); iterator insert(iterator position, const value_type& x); template <class InputIterator> void insert(InputIterator first, InputIterator last); void erase(iterator position); size_type erase(const key_type& x); void erase(iterator first, iterator last); // set operations: iterator find(const key_type& x) const; size_type count(const key_type& x) const; iterator lower_bound(const key_type& x) const; iterator upper_bound(const key_type& x) const; pair<iterator, iterator> equal_range(const key_type& x) const; };
4.3 STL
template <class Key, class Compare = less<Key>, template <class U> class Allocator = allocator> class set { public: // typedefs: typedef Key key_type; typedef Key value_type; typedef Allocator<Key>::pointer pointer; typedef Allocator<Key>::reference reference; typedef Allocator<Key>::const_reference const_reference; typedef Compare key_compare; typedef Compare value_compare; typedef iterator; typedef iterator const_iterator; typedef size_type; typedef difference_type; typedef reverse_iterator; typedef const_reverse_iterator; // allocation/deallocation: set(const Compare& comp = Compare()); template <class InputIterator> set(InputIterator first, InputIterator last, const Compare& comp = Compare()); set(const set<Key, Compare, Allocator>& x); ~set(); set<Key, Compare, Allocator>& operator=(const set<Key, Compare, Allocator>& x); void swap(set<Key, Compare, Allocator>& x);
59
Contenedores Set
#include<set.h> #include<iostream.h> void main() { set<int, less<int> > s; cout << "Cuenta (42) " << s.count(42) << endl; s.insert(42); cout << "Cuenta (42) " << s.count(42) << endl; s.insert(42); cout << "Cuenta (42) " << s.count(42) << endl; int cuenta = s.erase(42); cout << cuenta << " elemento borrado"; } Cuenta (42) 0 Cuenta (42) 1 Cuenta (42) 1 1 elemento borrado
4.3 STL
Tema 4: Genericidad
Set
#include<iostream.h> #include<set.h>
Contenedores
Introduce un nmero: 60 Se ha insertado un nuevo elemento: 60 Introduce un nmero: 90 Se ha insertado un nuevo elemento: 90 Introduce un nmero: 80 Se ha insertado un nuevo elemento: 80 Introduce un nmero: 10 El elemento ya exista: 10 10 20 30 40 50 60 80 90
4.3 STL
void main() { int num, array [] = {10, 20, 30, 40, 50}; typedef set<int, less<int> > setTipo; setTipo s(array, array+5); setTipo::iterator i; pair<setTipo::const_iterator, bool> p; do {
cout << "Introduce un nmero: "; cin >> num; p=s.insert(num); if (p.second) cout << endl << "Se ha insertado un nuevo elemento: " << *(p.first) << endl; else cout << "El elemento ya exista: " << *(p.first) << endl; } while (p.second); i=s.begin(); while( i!=s.end() ) cout << *i++ << endl; }
61
Multimap

Contenedores
4.3 STL
Es un contenedor asociativo capaz de manejar un conjunto ordenado de parejas clave-valor Las parejas estn ordenadas por la clave mediante una funcin de ordenacin suministrada por el usuario. Se debe tener cuidado de que los objetos implementen las operaciones requeridas por la funcin de ordenacin Ms de un valor puede asociarse con una clave particular La insercin no afecta a los iteradores o referencias El borrado slo invalida los iteradores y referencias a los elementos borrados Para su utilizacin debe incluirse el fichero cabecera multimap.h
62
Tema 4: Genericidad
Contenedores Multimap
template <class Key, class T, class Compare = less<Key>, template <class U> class Allocator = allocator> class multimap { public: // typedefs: typedef Key key_type; typedef pair<const Key, T> value_type; typedef Compare key_compare; class value_compare: public binary_function<value_type, value_type, bool> { friend class multimap; protected: Compare comp; value_compare(Compare c) : comp(c) {} public: bool operator()(const value_type& x, const value_type& y) { return comp(x.first, y.first); } }; typedef iterator; typedef const_iterator; typedef Allocator<value_type>::pointer pointer; typedef Allocator<value_type>::reference reference; typedef Allocator<value_type>::const_reference const_reference; typedef size_type; typedef difference_type; typedef reverse_iterator; typedef const_reverse_iterator; // allocation/deallocation: multimap(const Compare& comp = Compare()); template <class InputIterator> multimap(InputIterator first, InputIterator last, const Compare& comp = Compare()); multimap(const multimap<Key, T, Compare, Allocator>& x); ~multimap(); multimap<Key, T, Compare, Allocator>& operator=(const multimap<Key, T, Compare, Allocator>& x); void swap(multimap<Key, T, Compare, Allocator>& x); // accessors: key_compare key_comp() const; value_compare value_comp() const; iterator begin(); const_iterator begin() const; iterator end(); const_iterator end() const; reverse_iterator rbegin(); const_reverse_iterator rbegin(); reverse_iterator rend(); const_reverse_iterator rend(); bool empty() const; size_type size() const; size_type max_size() const; // insert/erase: iterator insert(const value_type& x); iterator insert(iterator position, const value_type& x); template <class InputIterator> void insert(InputIterator first, InputIterator last); void erase(iterator position); size_type erase(const key_type& x); void erase(iterator first, iterator last); // multimap operations: iterator find(const key_type& x); const_iterator find(const key_type& x) const; size_type count(const key_type& x) const; iterator lower_bound(const key_type& x); const_iterator lower_bound(const key_type& x) const; iterator upper_bound(const key_type& x); const_iterator upper_bound(const key_type& x) const; pair<iterator, iterator> equal_range(const key_type& x); pair<const_iterator, const_iterator> equal_range(const key_type& x) const; };
4.3 STL
63
Constructores
multimap ( )
Construye un multimap vaco que ordena sus claves utilizando la funcin especificada cuando se instanci la plantilla Construye un multimap que contiene copias de las parejas clave-valor en el rango [primero, ltimo), utilizando la funcin especificada cuando se instanci la plantilla Construye un multimap vaco que ordena sus claves utilizando la funcin comparacin
4.3 STL
multimap (const value_type* primero, const value_type* ltimo)
multimap (const Compare& comparacin)
multimap (const value_type* primero, const value_type* ltimo, const Compare& comparacin)
Construye un multimap que contiene copias de las parejas clave-valor en el rango [primero, ltimo), utilizando la funcin comparacin para ordenar sus claves
Operaciones
size_type count (const Key& clave) const
Retorna en nmero de parejas clave-valor cuya clave es clave Borra todas las parejas clave-valor donde la clave coincide con clave Si se contiene una pareja clave-valor que casa con clave, se retorna un iterador posicionado en la pareja clave-valor, en otro caso se devuelve un iterador posicionado en end() Inserta una copia de pareja, que es una pareja clave-valor, y retorna un iterador posicionado en la nueva pareja insertada
size_type erase (const Key& clave) iterator find (const Key& clave) iterator insert (const value_type& pareja)
64
Tema 4: Genericidad
#include <iostream> #include <multimap.h> void main() { typedef multimap<char, int, less<char> > mmap; mmap m; cout << "Cuenta ('X') = " << m.count('X') << endl; m.insert( mmap::value_type ('X', 200) ); cout << "Cuenta ('X') = " << m.count('X') << endl; m.insert( mmap::value_type ('X', 2000) ); cout << "Cuenta ('X') = " << m.count('X') << endl; m.insert( mmap::value_type ('Y', 100) ); mmap::iterator i = m.find('X'); while ( i!=m.end() ) { cout << (*i).first << " ---> " << (*i).second << endl; i++; } int cuantos = m.erase('X'); Cuenta ('X') = 0 cout << cuantos << " elementos borrados" << endl; Cuenta ('X') = 1 Cuenta ('X') = 2 X ---> 200 X ---> 2000 Y ---> 100 2 elementos borrados
4.3 STL
65
#include <iostream> #include <multimap.h> void main () { typedef multimap<int, char, less<int> > mmap; mmap::value_type p1(1, 'a'); mmap::value_type p2(10, 'A'); mmap::value_type p3(100, 'b'); mmap::value_type p4(10, 'B'); mmap::value_type p5(1000, 'c'); mmap::value_type p6(10, 'C'); mmap::value_type array [] = {p1,p2,p3,p4,p5,p6}; mmap m (array, array+6); mmap::iterator i; i=m.lower_bound(10); cout << "LOWER BOUND" << endl; cout << (*i).first << " ---> " << (*i).second << endl; i=m.upper_bound(10); cout << "UPPER BOUND" << endl; cout << (*i).first << " ---> " << (*i).second << endl; }
4.3 STL
LOWER BOUND 10 ---> A UPPER BOUND 100 ---> b
66
Tema 4: Genericidad
Contenedores Map
Es un contenedor asociativo capaz de manejar un conjunto ordenado de parejas clave-valor Las parejas estn ordenadas por la clave mediante una funcin de ordenacin suministrada por el usuario. Se debe tener cuidado de que los objetos implementen las operaciones requeridas por la funcin de ordenacin Exhibe el mismo comportamiento que un contenedor multimap a excepcin de que no permite que una pareja sea insertada si ya existe una pareja con la misma clave La insercin no afecta a los iteradores o referencias El borrado slo invalida los iteradores y referencias a los elementos borrados Para su utilizacin debe incluirse el fichero cabecera map.h
67
4.3 STL
Contenedores Map
template <class Key, class T, class Compare = less<Key>, template <class U> class Allocator = allocator> class map { public: // typedefs: typedef Key key_type; typedef pair<const Key, T> value_type; typedef Compare key_compare; class value_compare: public binary_function<value_type, value_type, bool> { friend class map; protected: Compare comp; value_compare(Compare c) : comp(c) {} public: bool operator()(const value_type& x, const value_type& y) { return comp(x.first, y.first); } }; typedef iterator; typedef const_iterator; typedef Allocator<value_type>::pointer pointer; typedef Allocator<value_type>::reference reference; typedef Allocator<value_type>::const_reference const_reference; typedef size_type; typedef difference_type; typedef reverse_iterator; typedef const_reverse_iterator; // allocation/deallocation: map(const Compare& comp = Compare()); template <class InputIterator> map(InputIterator first, InputIterator last, const Compare& comp = Compare()); map(const map<Key, T, Compare, Allocator>& x); ~map(); map<Key, T, Compare, Allocator>& operator=(const map<Key, T, Compare, Allocator>& x); void swap(map<Key, T, Compare, Allocator>& x); // accessors: key_compare key_comp() const; value_compare value_comp() const; iterator begin(); const_iterator begin() const; iterator end(); const_iterator end() const; reverse_iterator rbegin(); const_reverse_iterator rbegin(); reverse_iterator rend(); const_reverse_iterator rend(); bool empty() const; size_type size() const; size_type max_size() const; Allocator<T>::reference operator[](const key_type& x); // insert/erase: pair<iterator, bool> insert(const value_type& x); iterator insert(iterator position, const value_type& x); template <class InputIterator> void insert(InputIterator first, InputIterator last); void erase(iterator position); size_type erase(const key_type& x); void erase(iterator first, iterator last); // map operations: iterator find(const key_type& x); const_iterator find(const key_type& x) const; size_type count(const key_type& x) const; iterator lower_bound(const key_type& x); const_iterator lower_bound(const key_type& x) const; iterator upper_bound(const key_type& x); const_iterator upper_bound(const key_type& x) const; pair<iterator, iterator> equal_range(const key_type& x); pair<const_iterator, const_iterator> equal_range(const key_type& x) const; };
4.3 STL
68
Tema 4: Genericidad
Contenedores Map
Desde el punto de vista de la interfaz hay dos diferencias principales entre los contenedores multimap y map
pair <iterator, bool> insert (const value_type& pareja)
Si el conjunto no contiene una pareja clave-valor cuya clave coincida con la de pareja, se inserta una copia de pareja y retorna un objeto pair cuyo primer elemento es un iterador posicionado en la nueva pareja y el segundo es true. Si ya se contiene una pareja cuya clave coincide con la clave de pareja, retorna un objeto pair cuyo primer elemento es un iterador posicionado en el elemento existente y el segundo false
4.3 STL
Value& operator [ ] (const Key& clave)

Si no existe un valor asociado con clave, se asocia la clave con un valor predeterminado y se retorna una referencia al nuevo valor, en caso contrario se retorna una referencia al valor ya asociado
69
Map
#include <iostream> #include <map.h>
Contenedores
4.3 STL
void main() { typedef map<char, int, less<char> > maptype; maptype m; // Equivalencias entre nmeros romanos y arbigos m['L'] = 50; m['X'] = 20; // Error deliberado m['X'] = 20 m['V'] = 5; m['Z'] = 0 m['I'] = 1; Primera insercin realizada con xito Par existente: C ---> 100 cout << "m['X'] = " << m['X'] << endl; m['X'] = 10; // Se corrige el error // Se aade un valor por defecto (0) a la lista cout << "m['Z'] = " << m['Z'] << endl; pair<maptype::iterator, bool> p; p=m.insert(maptype::value_type ('C', 100)); if (p.second) cout << "Primera insercin realizada con xito" << endl; p=m.insert(maptype::value_type ('C', 200)); if (p.second) cout << "Segunda insercin realizada con xito" << endl; else cout << "Par existente: " << (*(p.first)).first << " ---> " << (*(p.first)).second << endl;
70
Tema 4: Genericidad
Adaptadores
4.3 STL
Los adaptadores permiten utilizar contenedores que soporten una interfaz determinada Los adaptadores no soportan iteracin, por lo que no pueden tener iteradores asociados STL cuenta con tres adaptadores
stack (pila) queue (cola) priority_queue (cola de prioridad)
71
Stack
Adaptadores
4.3 STL
Una pila (stack) es un adaptador que permite utilizar cualquier contenedor que soporte las operaciones push_back() y pop_back() como una estructura de datos LIFO Se utiliza para implementar estructuras LIFO donde los accesos indexados directos no estn permitidos Adicionalmente a las operaciones comunes a cualquier coleccin, las pilas ofrecen el siguiente comportamiento especializado
void push (const T& valor)
Inserta al final una copia de valor
void pop ( )
Borra el ltimo elemento introducido
T& top ( )
Retorna una referencia al ltimo elemento introducido
Tema 4: Genericidad
Stack
#include <deque.h> #include <stack.h> #include <iostream.h>
Adaptadores
#include <list.h> #include <stack.h> #include <iostream.h> void main() { stack<int, list<int> > s; s.push(1000); s.push(-10); s.pop(); s.push(69); s.push(13); while ( !s.empty() ) { cout << s.top() << endl; s.pop(); } }
4.3 STL
void main() { stack<int, deque<int> > s; s.push(1000); s.push(-10); s.pop(); s.push(69); s.push(13); while ( !s.empty() ) { cout << s.top() << endl; s.pop(); } }
13 69 1000
73
Queue
Adaptadores
4.3 STL
Una cola (queue) es un adaptador que permite utilizar cualquier contenedor que soporte los mtodos push_back() y pop_front() como una estructura de datos FIFO Se utiliza para implementar estructuras FIFO donde los accesos indexados directos no estn permitidos Su implementacin es tal que los mensajes a los mtodos push() y pop() se traducen en mensajes a los mtodos push_back() y pop_front()
74
Tema 4: Genericidad
Adaptadores Queue
#include <iostream> #include <queue> #include <deque.h> void main(){ queue<int, deque<int> > q; q.push(30); q.push(40); q.push(50); while( !q.empty() ) { cout << q.front() << endl; q.pop(); } }
4.3 STL
30 40 50
75
Adaptadores Priority_Queue
Una cola de prioridad (priority_queue) es un adaptador que permite utilizar cualquier contenedor que cuente con un iterador de acceso aleatorio para mantener una coleccin ordenada de elementos Los nicos contenedores secuenciales que cuentan con iteradores aleatorios son vector y deque, donde deque generalmente ofrece un mejor rendimiento Permite especificar una funcin de ordenacin para ordenar los elementos Este adaptador no introduce nuevas funciones
4.3 STL
76
Tema 4: Genericidad
Adaptadores Priority_Queue
#include<iostream> #include<queue> #include<deque.h> void main() { priority_queue<int, deque<int>, less<int> > pq; pq.push(42); pq.push(101); pq.push(69); while( !pq.empty() ) { cout << pq.top() << endl; pq.pop(); } } 101 69 42
4.3 STL
77
Priority_Queue
#include<iostream> #include<queue> #include<deque.h> #include<string.h>
Adaptadores
4.3 STL
class greater_s { public: bool operator () (const char *s1, const char *s2) const { return strcmp (s1, s2) > 0; } }; void main() { priority_queue<char*, deque<char*>, greater_s > pq; pq.push("Mary"); pq.push("Ana"); pq.push("Trinidad"); while( !pq.empty() ) { cout << pq.top() << endl; pq.pop(); } }
Ana Mary Trinidad
78
Tema 4: Genericidad
4.3 STL
Iteradores Una de las caractersticas que diferencian a la STL de otras bibliotecas es su uso exhaustivo de los iteradores Un iterador puede considerarse como un tipo generalizado de puntero, que puede utilizarse para recorrer los elementos de una coleccin Un iterador se posiciona exactamente en lugar de la coleccin, recordando su posicin hasta que reciba la orden de moverse Existen cinco categoras principales de iteradores, que se organizan de forma jerrquica
entrada, salida, hacia delante, bidireccional y acceso aleatorio
Existen tipos especiales de iteradores

hacia atrs y constantes
4.3 STL
Iteradores Entrada Salida
Hacia delante
Bidireccional
Jerarqua de iteradores
80
Acceso aleatorio
Tema 4: Genericidad
4.3 STL
Iteradores
Tipos de iteradores
De entrada
Puede leer un elemento de cada vez en direccin hacia delante solamente
De salida
Puede escribir un elemento de cada vez en direccin hacia delante solamente
Hacia delante
Combina las caractersticas de los iteradores de entrada y salida
Bidireccional
Como el iterador hacia delante, pero con la capacidad de moverse hacia atrs
Acceso aleatorio
Como el iterador bidireccional, pero con la habilidad de saltar una distancia arbitraria
Hacia atrs
Como el iterador hacia delante, pero en sentido contrario
Constante
Permite iterar a travs de una coleccin constante
81
4.3 STL
Iteradores
Comportamiento de los iteradores (i)
Su interfaz es simple En los siguientes ejemplos se asume que i, j son dos iteradores y n es un entero Comn a todos los iteradores
++ i - Avanza un elemento y retorna una referencia a i i ++ - Avanza un elemento y retorna el valor anterior
Entrada
*i - Retorna una referencia de slo lectura al elemento que ocupa la posicin actual donde apunta i i = = j - Retorna verdadero si i y j estn posicionados en el mismo elemento i ! = j - Retorna verdadero si i y j no estn posicionados en el mismo elemento
Salida
*i - Retorna una referencia al elemento que ocupa la posicin actual donde apunta i i = j - Hace que i se posiciones en el mismo lugar que j
Tema 4: Genericidad
4.3 STL
Iteradores
Comportamiento de los iteradores (ii)
Bidireccional
-- i - Retrocede un elemento y retorna el nuevo valor de i i -- - Retrocede un elemento y retorna el valor previo de i
Acceso aleatorio
i += n - Avanza n posiciones y retorna una referencia a i i -= n - Retrocede n posiciones y retorna una referencia a i i + n - Retorna un iterador que se posiciona n elementos a partir de la posicin actual de i i - n - Retorna un iterador que se posiciona n elementos detrs de la posicin actual de i i[n] - Retorna una referencia al n-simo elemento a partir de la posicin actual de i
83
4.3 STL
Iteradores
Contenedor vector deque list m ultiset set m ultim ap m ap stack queue priority_queue
Typedef iterator const_iterator reverse_iterator
Tipo de iterador acceso aleatorio acceso aleatorio bidireccional bidireccional bidireccional bidireccional bidireccional ninguno ninguno ninguno
Contenedores y sus tipos de iteradores
Significado Tipo que puede iterar hacia delante a travs de una coleccin en la que se puede escribir Tipo que puede iterar hacia delante a travs de una coleccin de slo lectura Tipo que puede iterar hacia atrs a travs de una coleccin en la que se puede escribir
const_reverse_iterator Tipo que puede iterar hacia atrs a travs de una coleccin de slo lectura
84
Tema 4: Genericidad
4.3 STL
Iteradores
Todo tipo de contenedor ofrece un conjunto de funciones para obtener un iterador posicionado en uno de sus extremos
iterator begin( )
Retorna un iterador posicionado en el primer elemento
const_iterator begin( ) const

Retorna un iterador posicionado en el primer elemento de una coleccin de slo lectura
iterator end( )
Retorna un iterador posicionado inmediatamente despus del ltimo elemento
const_iterator end( ) const

Retorna un iterador posicionado inmediatamente despus del ltimo elemento de una coleccin de slo lectura
Cuando un iterador est posicionado dentro de una coleccin puede ser desrreferenciado sin problemas. Sin embargo, cuando posicionado en la posicin end(), cualquier intento de desrreferencia puede causar un error de ejecucin
85
4.3 STL
Iteradores
Los iteradores hacia atrs son como los iteradores regulares excepto porque ellos recorren la coleccin en sentido inverso Todo tipo de contenedor ofrece un conjunto de funciones para obtener un iterador posicionado en uno de sus extremos
reverse_iterator rbegin( )
Retorna un iterador hacia atrs posicionado en el ltimo elemento
const_reverse_iterator rbegin( ) const

Retorna un iterador hacia atrs constante posicionado en el ltimo elemento de una coleccin de slo lectura
reverse_iterator rend( )
Retorna un iterador hacia atrs posicionado inmediatamente antes del primer elemento
const_reverse_iterator rend( ) const

Retorna un iterador hacia atrs constante posicionado inmediatamente antes del primer elemento de una coleccin de slo lectura
Tema 4: Genericidad
4.3 STL
Iteradores
#include<iostream> #include<deque.h> void main() { deque<char *> d; d.push_back("C++"); d.push_back("JAVA"); d.push_front("EIFFEL"); deque<char *>::reverse_iterator i; for (i=d.rbegin(); i!=d.rend(); i++) cout << *i << endl; } JAVA C++ EIFFEL
87
4.3 STL
Algoritmos
En el diseo de la biblioteca STL se pone de manifiesto el inters de los autores por que los algoritmos fueran tratados como entidades de primera clase, pudindose as aplicar a una gran variedad de estructuras de datos Entender la separacin que hace STL de las estructuras de datos y de los algoritmos es la base para la creacin de nuevos algoritmos genricos Aunque hay algoritmos que operan con parejas de elementos, la mayora de ellos lo hacen con secuencias, requiriendo algunos de ellos iteradores ms complicados Para su utilizacin se debe emplear el fichero cabecera algo.h (en algunas implementaciones algorithm.h)
Se utiliza #include<algorithm>
Tema 4: Genericidad
4.3 STL
Algoritmos
accumulate
Suma valores en un rango template<class InputIterator, class T> T accumulate (InputIterator primero, InputIterator ultimo, T inicial) template<class InputIterator, class T, class BinaryOperation> T accumulate (InputIterator primero, InputIterator ultimo, T inicial, BinaryOperation op) Aade el valor de cada elemento del rango [primer, ltimo) a inicial y retorna el nuevo valor de inicial La complejidad temporal es lineal
#include<algorithm> #include<vector.h> #include<iostream> La suma es 15 void main() { int array[] = {1,2,3,4,5}; vector<int> v(array, array+5); int sum = accumulate (v.begin(), v.end(), 0); cout << "La suma es " << sum << endl; } Departamento de Informtica y Automtica - Universidad de Salamanca 89
4.3 STL
Algoritmos
#include<algorithm> #include<iostream> #include<vector.h> int mult (int inicio, int elemento) { return inicio*elemento; } void main() { int array[] ={1,2,3,4,5}; vector<int> v(array, array+5); int prod = accumulate (v.begin(), v.end(), 1, mult); cout << "El producto es " << prod << endl; }
El producto es 120
90
Tema 4: Genericidad
4.3 STL
Algoritmos
merge
Une dos listas ordenadas en una sola lista ordenada template<class InputIterator1, class InputIterator, class OutputIterator> OutputIterator merge (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator last2, OutputIterator resultado) template<class InputIterator1, class InputIterator, class OutputIterator, class Compare> OutputIterator merge (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator last2, OutputIterator resultado, Compare funcion) Retorna un iterador igual a resultado + n donde n = (last1 - first1) + (last2 - first2) La primera versin asume que las dos listas estn ordenadas mediante el operador <, mientras que la segunda asume que ambas listas estn ordenadas utilizando la funcin binaria funcin
4.3 STL
Algoritmos
#include<iostream> #include<algorithm> void main() { int numeros1[]={1,5,65,334,500}; int numeros2[]={-13,23,45,54,69}; int resultado[10]; merge(numeros1, numeros1+5, numeros2, numeros2+5, resultado); for (int i=0; i<10; cout << resultado[i++] << ' '); cout << endl; } #include<algorithm> #include<vector.h> #include<iterator.h> #include<iostream> void main() { vector<int> v1(5); vector<int> v2(v1.size());
-13 1 5 23 45 54 65 69 334 500
0 1 2 3 4 3 4 5 6 7 0 1 2 3 3 4 4 5 6 7
// iota -> rellena un rango con valores ascendentes iota(v1.begin(), v1.end(), 0); iota(v2.begin(), v2.end(), 3); vector<int> resultado (v1.size()+v2.size()); merge(v1.begin(), v1.end(), v2.begin(), v2.end(), resultado.begin()); ostream_iterator <int> iter (cout, " "); //copy -> copia un rango de un rea a otra copy (v1.begin(), v1.end(), iter); cout << endl; copy (v2.begin(), v2.end(), iter); cout << endl; copy (resultado.begin(), resultado.end(), iter); cout << endl;
92
Tema 4: Genericidad
4.3 STL
Algoritmos
#include<algorithm> #include<vector.h> #include<iterator.h> #include<iostream> void main() { vector<int> v1(5); vector<int> v2(v1.size()); iota(v1.begin(), v1.end(), 0); iota(v2.begin(), v2.end(), 3); vector<int> resultado (v1.size()+v2.size()); merge(v1.rbegin(), v1.rend(), v2.rbegin(), v2.rend(), resultado.begin(),greater<int>()); ostream_iterator <int> iter (cout, " "); copy (v1.begin(), v1.end(), iter); cout << endl; copy (v2.begin(), v2.end(), iter); cout << endl; copy (resultado.begin(), resultado.end(), iter); cout << endl; } Departamento de Informtica y Automtica - Universidad de Salamanca 93 0 1 2 3 4 3 4 5 6 7 7 6 5 4 4 3 3 2 1 0
Funciones y Objetos Funcin

La biblioteca STL permite definir objetos funcin, lo que permite la existencia de funciones encapsuladas como objetos Muchos algoritmos y contenedores en la biblioteca STL requieren que se especifique una funcin para realizar su tarea
La funcin que toma un parmetro se denomina unaria La funcin que toma dos parmetros se denomina binaria
4.3 STL
En STL se catalogan las funciones de la siguiente manera

Predicados: Siempre retornan un valor lgico. Se utilizan como lanzadores de operaciones Comparadores: Siempre retornan un valor lgico. Se utilizan para ordenar elementos Funciones generales: Suelen retornar un valor numrico. Realizan una operacin arbitraria sobre uno o ms parmetros
Las funciones de STL suelen estar declaradas en el fichero cabecera function.h (functional.h en algunas implementaciones)
Se utiliza #include<functional>
94
Tema 4: Genericidad
Funciones y Objetos Funcin

#include<iostream> #include<algorithm> #include<functional> Hay 5 ceros
4.3 STL
void main() { int prueba [] = {0,1,1,1,1,0,0,0,1,0,1}; int n=0; count_if (prueba, prueba+11, logical_not<int>(), n); cout << "Hay " << n << " ceros" << endl; } #include<iostream> #include<algorithm> #include<functional> void main() { int prueba [] = {80,-90,100,-2000}; int resultado [4]; transform(prueba, prueba + 4, resultado, negate<int> () ); for (int i=0;i<4; i++) cout << resultado[i] << " "; cout << endl; } Departamento de Informtica y Automtica - Universidad de Salamanca 95
-80 90 -100 2000
5. Referencias
[Crespo, 2000] Crespo Gonzlez-Carvajal, Yania. Incremento del Potencial de Reutilizacin del Software mediante una Refactorizacin para Parametrizar. Tesis Doctoral. Universidad de Valladolid. 2000. [Goguen, 1984] Goguen, J. Parametrized Programming. IEEE Transactions on Software Engineering, 10(5):528-543, 1984. [Meyer, 1997] Meyer, Bertrand. Object Oriented Software Construction. 2nd Edition. Prentice Hall, 1997. [Musser and Stepanov, 1987] Musser, D. R. and Stepanov, A. A. A Library of Generic Algorithms in Ada Proceedings of 1987 ACM SIGAda International Conference, Boston, December, 1987. [Musser and Stepanov, 1989] Musser, David R. and Stepanov, Alexander A. Generic Programming. In Proceedings of the First International Joint Conference of ISSAC-88 and AAECC-6. P. Gianni editor. (Rome, Italy, July 4-8, 1988). Published in Lecture Notes in Computer Science 358, Pages 13-25. Springer-Verlag, 1989. [Musser and Stepanov, 1994] Musser, David R. and Stepanov, Alexander A. AlgorithmOriented Generic Library. Software Practice & Experience, 24(7):623-642. July, 1994. [Musser and Stepanov, 1998] Musser, David R. and Stepanov, Alexander A. Generic Programming. Dagstuhl Seminar on Generic Programming. 1998. [Stepanov and Lee, 1994] Stepanov, A. A. and Lee, M. The Standard Template Library. Technical Report HPL-94-34, Hewlett-Packard Laboratories, April 1994. [Stroustrup, 1997] Stroustrup, Bjarne. The C++ Programming Language. 3rd Edition, Addison Wesley, 1997. [X3J16/WG21, 1996] ANSI X3J16 and ISO WG21. Working Paper for Draft Proposed International Standard for Information SystemsProgramming Language C++. ftp://research.att.com/dist/c++std/WP/CD2. [ltima vez visitado 7/1/2000]. X3J16/96 0225 (WG21/N1043). December, 1996.
96
Tema 4: Genericidad
6. Lecturas Complementarias
Devis Botella, Ricardo. Contenedores y Plantillas en C++. Revista Profesional para Programadores (RPP), Editorial Anaya Multimedia, II(5):61-71. Marzo, 1995. Artculo sobre las facilidades ofrecidas por C++ para la creacin de contenedores parametrizables empleando plantillas. Meyer, Bertrand. Construccin de Software Orientado a Objetos. 2 Edicin. Prentice Hall, 1999. El captulo 10, Genericidad, contiene una introduccin a la genericidad. Musser, David R. and Stepanov, Alexander A. Generic Programming. In Proceedings of the First International Joint Conference of ISSAC-88 and AAECC-6. P. Gianni editor. (Rome, Italy, July 4-8, 1988). Published in Lecture Notes in Computer Science 358, Pages 13-25. Springer-Verlag, 1989. Introduccin a la programacin genrica. Artculo centrado en las abstracciones algortmicas ms que en las estructuras de datos. Musser, David R. and Stepanov, Alexander A. Algorithm-Oriented Generic Library. Software Practice & Experience, 24(7):623-642. July, 1994. Trabajo sobre bibliotecas de algoritmos genricos, predecesor a STL. Stepanov, A. A. and Lee, M. The Standard Template Library. STL Documentation. October. 1995. Manual que se inclua con la distribucin pblica de la biblioteca STL.
97

Tema 4

Diunggah oleh

Informasi Dokumen

Judul Asli

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

Tema 4

Diunggah oleh

Hak Cipta:

Format Tersedia

Tema 4: Genericidad

Departamento de Informtica y Automtica - Universidad de Salamanca

Departamento de Informtica y Automtica - Universidad de Salamanca

Departamento de Informtica y Automtica - Universidad de Salamanca

Departamento de Informtica y Automtica - Universidad de Salamanca

1.1 Presentacin de la genericidad

Departamento de Informtica y Automtica - Universidad de Salamanca

1.2 Generalizacin de tipos

Genericidad Lista de Revistas

2. Tipos Paramtricos y Clases Genricas

Departamento de Informtica y Automtica - Universidad de Salamanca

Departamento de Informtica y Automtica - Universidad de Salamanca

2.1 Necesidad de la parametrizacin de tipos

En un lenguaje OO las clases genricas facilitan un incremento de la calidad de software en cuanto

Departamento de Informtica y Automtica - Universidad de Salamanca

Departamento de Informtica y Automtica - Universidad de Salamanca

Departamento de Informtica y Automtica - Universidad de Salamanca

Departamento de Informtica y Automtica - Universidad de Salamanca

Departamento de Informtica y Automtica - Universidad de Salamanca

Departamento de Informtica y Automtica - Universidad de Salamanca

Departamento de Informtica y Automtica - Universidad de Salamanca

Departamento de Informtica y Automtica - Universidad de Salamanca

Departamento de Informtica y Automtica - Universidad de Salamanca

Departamento de Informtica y Automtica - Universidad de Salamanca

Departamento de Informtica y Automtica - Universidad de Salamanca

Departamento de Informtica y Automtica - Universidad de Salamanca

Departamento de Informtica y Automtica - Universidad de Salamanca

Departamento de Informtica y Automtica - Universidad de Salamanca

Departamento de Informtica y Automtica - Universidad de Salamanca

Departamento de Informtica y Automtica - Universidad de Salamanca

Departamento de Informtica y Automtica - Universidad de Salamanca

Departamento de Informtica y Automtica - Universidad de Salamanca

Departamento de Informtica y Automtica - Universidad de Salamanca

Departamento de Informtica y Automtica - Universidad de Salamanca

Departamento de Informtica y Automtica - Universidad de Salamanca

Departamento de Informtica y Automtica - Universidad de Salamanca

Departamento de Informtica y Automtica - Universidad de Salamanca

Departamento de Informtica y Automtica - Universidad de Salamanca

Departamento de Informtica y Automtica - Universidad de Salamanca

Departamento de Informtica y Automtica - Universidad de Salamanca

Departamento de Informtica y Automtica - Universidad de Salamanca

Departamento de Informtica y Automtica - Universidad de Salamanca

Departamento de Informtica y Automtica - Universidad de Salamanca

Departamento de Informtica y Automtica - Universidad de Salamanca

Departamento de Informtica y Automtica - Universidad de Salamanca

Departamento de Informtica y Automtica - Universidad de Salamanca

Departamento de Informtica y Automtica - Universidad de Salamanca

Departamento de Informtica y Automtica - Universidad de Salamanca

vector (size_type n, const T& valor)

vector (const T* primero, const T* ltimo)

T& operator [ ] (int ndice)

void push_back (const T& valor)

void erase (iterator primero, iterator ltimo)

iterator insert (iterator pos, const T& valor)

void insert (iterator pos, size_type n, const T& valor)

void insert (iterator pos, const T* primero, const T* ltimo)

size_type capacity ( ) const

void reserve (size_type n)

Departamento de Informtica y Automtica - Universidad de Salamanca

Departamento de Informtica y Automtica - Universidad de Salamanca

v[0] v[1] v[2] v[3] v[4] v[0] v[1] v[2] v[3]

v[0] = 2 v[1] = 3 v[2] = 4 v[0] = 2 v[1] = 4

Departamento de Informtica y Automtica - Universidad de Salamanca