CONTENEDORES

cout <<
((evento)(*it)).getEvent_type()<<
", "<<endl;

Carlos Brito
LA BIBLIOTECA DE PLANTILLAS
ESTÁNDAR DE C ++ (STL)

La Biblioteca de plantillas estándar (STL) es un conjunto de clases

de plantillas de C ++ para proporcionar estructuras y funciones de
datos de programación comunes como listas, pilas, matrices, etc.
Es una biblioteca de clases de contenedores, algoritmos e
iteradores. Es una biblioteca generalizada y, por lo tanto, sus
componentes están parametrizados. Un conocimiento práctico
de las clases de plantilla es un requisito previo para trabajar con
STL.

STL tiene cuatro componentes:

 Algoritmos: El algoritmo de encabezado define una colección

de funciones especialmente diseñadas para usarse en rangos de
elementos. Actúan en contenedores y proporcionan medios
para diversas operaciones para el contenido de los
contenedores.
 Las funciones: El STL incluye clases que sobrecargan el
operador de llamada de función. Las instancias de tales clases
se denominan objetos de función o functores. Los functors
permiten personalizar el funcionamiento de la función asociada
con la ayuda de los parámetros que se pasan.
 Iteradores Como su nombre indica, los iteradores se utilizan
para trabajar sobre una secuencia de valores. Son la
característica principal que permite la generalidad en STL.
CONTENEDORES

 Son estructuras de datos predefinidas por STL, con la características

de contener cualquier tipo de clase permiten implementar estructuras
de datos comunes fácilmente, como colas, listas y pilas.
 El contenedor gestiona el espacio de almacenamiento que es
asignado a sus elementos y proporciona funciones miembro para
acceder a ellos, ya sea directamente o mediante iteradores.
 La mayoría de los contenedores tienen varias funciones miembro en
común, y comparten ciertas funcionalidades. Qué contenedor es
mejor para una aplicación particular no sólo depende de la
funcionalidad ofrecida, sino también de su eficiencia para los
diferentes tipos de trabajo.
VENTAJAS
✓Al ser estándar, está (o estará) disponible por todos los compiladores
y plataformas. Esto permitirá utilizar la misma librería en todos los
proyectos y disminuirá el tiempo de aprendizaje necesario para que
los programadores cambien de proyecto.
✓El uso de una librería de componentes reutilizables incrementa la
productividad ya que los programadores no tienen que escribir sus
propios algoritmos. Además, utilizar una librería libre de errores no
sólo reduce el tiempo de desarrollo, sino que también incrementa la
robustez de la aplicación en la que se utiliza.
✓Las aplicaciones pueden escribirse rápidamente ya que se construyen
a partir de algoritmos eficientes y los programadores pueden
seleccionar el algoritmo más rápido para una situación dada.
✓Se incrementa la legibilidad del código, lo que hará que éste sea
mucho más fácil de mantener.
✓Proporciona su propia gestión de memoria. El almacenamiento de
memoria es automático y portátil, así el programador ignorará
problemas tales como las limitaciones del modelo de memoria del PC.
TIPOS DE CONTENEDORES

La Librería Estándar C++ contiene diez formas de contenedores y

tres adaptadores de contenedor (denominados simplemente
adaptadores). En esta sección se expondrán brevemente cuales
son estas formas; sus características, y cuál es la más adecuada
para cada tipo de problema específico.

✓Contenedores asociativos: implementa estructuras de datos

ordenadas que se pueden buscar rápidamente (complejidad O
(log n) ) almacena objetos de forma ordenada basándose en una
llave.
 CONTENEDORES ASOCIATIVOS
(VECTOR)

Generalización de un vector o array que

almacena una colección de elementos del
mismo tipo. Los elementos se acceden de
manera directa por medio de un índice, en el
rango de 0 a n-1, siendo n el tamaño del vector.
Dicho tamaño puede aumentarse o
decrementarse según las necesidades de
manera dinámica.
vector<string> sentence;
// Se reserva espacio para 5 elementos para
// evitar que se tenga que resituar la memoria. La forma de declarar un vector es muy
sentence.reserve(5); parecida a declarar un tipo de dato solo
que hay que indicar el tipo de dato a
sentence.push_back("Hello,"); almacenar:
sentence.push_back("how");
 vector<int> vectorEnteros;
sentence.push_back("are");
sentence.push_back("you");  vector<String> vectorCadenas;
sentence.push_back("?");  vector<MiTipo> vectorMiTipo;
cout<< "max_size(): "<< sentence.max_size()<< endl;
 vector<queue<double>>
cout<< "size(): "<< sentence.size() << endl; vectorDeColas;
cout<< "capacity(): "<< sentence.capacity()<< endl;
// Intercambio de elementos.
swap (sentence[1], sentence[3]);
// Inserción de "always" antes de "?"
sentence.insert(find(sentence.begin(),sentence.end(),"?"),"always");
// Se asigna "!" al último elemento.
sentence.back() = "!";
 CONTENEDORES ASOCIATIVOS
(LIST)

Las listas son contenedores de // Un simple ejemplo de uso de la plantilla de

secuencia que permiten la clase list
asignación de memoria no contigua. #include <cstdlib>
En comparación con vector, la lista #include <iostream>
tiene un recorrido lento, pero una #include <iomanip>
vez que se ha encontrado una #include <list>
posición, la inserción y la eliminación
son rápidas. Normalmente, cuando using namespace std;
decimos una lista, hablamos de una
lista doblemente enlazada. Para int main(int argc, char *argv[])
implementar una lista enlazada {
individualmente, usamos la lista list<double> lalista;//Instanciamos la clase
hacia adelante. list
double num, suma=0;

cout << "Una sencilla calculadora" << endl;

do
{
La forma de declarar un LIST es cout << "Ingrese un número, 0 para salir: ";
muy parecida a declarar un tipo de cin >> num;
dato solo que hay que indicar el if (num != 0) lalista.push_back(num);
tipo de dato a almacenar: }
while (num != 0);
list<int> ListaEnteros;
cout << "----------" << endl;
list <String> ListaCadenas;
list <MiTipo> ListaMiTipo; while( !lalista.empty() )
{
list <queue<double>> ListDeColas; num = lalista.front();
cout << setw(10) << num << endl;
suma += num;
lalista.pop_front();
}
cout << "----------" << endl;

cout << setw(10) << suma << endl;

system("PAUSE");
return EXIT_SUCCESS;
}