Programación en C++/Librería Estándar de Plantillas

Editores:

Oscar E. Palacios

Biblioteca estándar de plantillas

Vectores

Colas de doble fin

La STL (Standard Template Library) de C++ es una colección genérica de plantillas de clases y algoritmos que permite a los programadores implementar fácilmente estructuras estándar de datos como colas (queues), listas (lists), y pilas (stacks).

La STL de C++ provee a los programadores con lo constructores siguientes, agrupados en tres categorias:

Secuencias (sequences)

C++ Vectors
C++ Lists
C++ Double-Ended Queues

Adaptadores de contenedor (Container Adapters)

C++ Stacks
C++ Queues
C++ Priority Queues

Contenedores asociativos (Associative Containers)

C++ Bitsets
C++ Maps
C++ Multimaps
C++ Sets
C++ Multisets

La idea detras de la STL de C++ es que la parte dificil en el uso de estructuras complejas de datos ya ha sido previamente completada. Por ejemplo, si un programador desea usar un stack de enteros, todo lo que tiene que hacer es escribir el código:

stack<int> myStack;

Con un minimo de esfuerzo, él o ella puede usar la función push() para ingresar enteros al stack; y la función pop() para retirar enteros del stack. A través de la magia de las plantillas de C++, se puede especificar cualquier tipo de dato, no sólo enteros. La clase Stack de la STL provee la funcionalidad genérica de un stack, sin importar el tipo de dato en el stack.

El termino iterar significa (en palabras sencillas) el método o forma que se usa para poder navegar sobre los elementos de una lista específica. Luego, un iterador es como una especie de "puntero especial" que nos permite leer o escribir valores sobre cada uno de los elementos en una lista. Los iteradores pueden ser comparados con los índices que se emplean para leer o escribir valores sobre los elementos de una lista. Igual a lo que sucede con los tipos de datos dentro de un arreglo primitivo en donde para leer o escribir valores sobre los elementos se tiene que prestar atención al tipo de dato, un iterador tiene que ser del tipo de dato que posee la lista. En ese sentido, si tenemos por ejemplo un vector que posee datos de tipo entero (int) entonces el iterador tendrá que ser de tipo entero; si por el contrario se tiene un vector cuyos datos son del tipo cadena (string) entonces el iterador tiene que ser del tipo cadena.

Sintaxis

La sintaxis general para la declaración de un iterador es:

NombrePlantilla<tipo>::iterator varid;

Donde,

NombrePlantilla	Es el nombre de una STL
tipo	Es el tipo usado para la plantilla
::iterator	Es el método para obtener el iterador
varid	Es el nombre de la variable

Por ejemplo, para obtener un iterador a un vector de tipo int podemos usar la instruccion:

vector <int>::iterator el_iterador;

A manera de ejemplo, vamos a mostrar un programa en el que se usará un iterador de tipo char.

Nota: en el programa se hace uso de los métodos begin para obtener un iterador hacia el inicio del vector, y end para obtener un iterador hacia el final del mismo.

// Demostracion del uso de iteradores
// probado en: Dev-C++ 4.9.9.2
 
#include <cstdlib>
#include <iostream>
#include <vector>
 
using namespace std;
 
int main(int argc, char *argv[])
{
    vector<char> v;
 
    for (char x = 'A'; x <= 'Z'; x++)
        v.push_back(x);
 
    // obtenemos un iterator del tipo char
    vector<char>::iterator it;

    // lectura y despliegue de datos
    cout << "\ndesplegando datos" << endl;
    for( it = v.begin(); it != v.end(); it++ )
        cout << *it << endl;
 
    system("PAUSE");
    return EXIT_SUCCESS;
}

Iteradores reversos

La STL de C++ permite que los elementos de las listas creadas puedan ser navegados en orden "normal", es decir desde el primero hasta el último de los elementos agregados a la lista, y para dichas tareas se usa un iterador normal. También, los elementos pueden navegarse en orden "reverso" y en tales casos se usa un iterador en reverso ( reverse_iterator ). Un ejemplo de reverse_iterator se muestra en el siguiente programa.

Notas:

Se debe de observar que para obtener iteradores normales se usan (generalmente) los métodos begin() y end(), mientras que que para obtener iteradores reversos se emplean los métodos rbegin() y rend().
Los iteradores reversos se comportan de manera inversa. Por ejemplo, para obtener un iterador que vaya desde el final hasta el inicio de los elementos, se usa la función rbegin() la cual regresará un iterador para procesar la lista desde el último hasta el primero de los elementos. En contraparte, la función begin() regresa un iterador para procesar la lista desde el primero hasta el último de los elementos. Es decir, begin() regresa una referencia hacia el primer elemento, mientras que rbegin() regresa una referencia hacia el último elemento.

// Demostracion del uso de iteradores reversos
// probado en: Dev-C++ 4.9.9.2
 
#include <cstdlib>
#include <iostream>
#include <list>
 
using namespace std;

int test()
{
  list<char> v;

  for (char x = 'A'; x <= 'Z'; x++) v.push_back(x);
  cout << endl;

  cout << "orden original" << endl;
  // creamos un iterator normal
  list<char>::iterator i = v.begin();
  while(i != v.end() )
  {
    cout << *i++ << " ";
  }
  cout << endl;

  cout << "orden inverso" << endl;
  // creamos un iterator reverso
  list<char>::reverse_iterator ri = v.rbegin();
  while(ri != v.rend() )
  {
    cout << *ri++ << " ";
  }
  cout << endl;
  return 0;
}


int main(int argc, char *argv[])
{
  test();
  system("PAUSE");
  return EXIT_SUCCESS;
}