C++ / vector

Bienvenidos sean a este post, hoy veremos a un contenedor de stl.

En el post anterior dijimos que este contenedor es de los tipos secuencial. Si tuvieramos que hacer una comparacion, son muy similares a los arrays pero con algunas particularidades con respecto a estos. Analicemos el siguiente ejemplo:

#include <iostream>
#include <string.h>
#include <vector>

class Coche
{
public:
        Coche(): suMarca("Generica"), suModelo("Generico") {}
        Coche(std::string marca, std::string modelo):
                suMarca(marca), suModelo(modelo)
                {}
        std::string GetMarca() const { return suMarca; }
        std::string GetModelo() const { return suModelo; }
private:
        std::string suMarca;
        std::string suModelo;
};

std::ostream & operator<< (std::ostream & salida, const Coche & rhs)
{
        salida << "Su marca es " << rhs.GetMarca();
        salida << " y el modelo es " << rhs.GetModelo();
        return salida;
}

template < class T >
void mostrar_vector(const std::vector< T > & v)
{
        std::cout << "max_size(): " << v.max_size();
        std::cout << "\tsize(): " << v.size();
        std::cout << "\tcapacity(): " << v.capacity();
        std::cout << "\t" << (v.empty() ? "vacio\n" : "no vacio\n");
        for(int i = 0; i < v.size(); i++)
                std::cout << v[i] << std::endl;
}

typedef std::vector< Coche > Cochera;

int main()
{
        Coche coche1;
        Coche coche2("VW","GOL");
        Coche coche3("FORD","ECOSPORT");
        Coche coche4("AUDI","Q3");
        Cochera cocheraVacia;
        mostrar_vector(cocheraVacia);
        std::cout << " +++ Nueva cochera +++\n";
        Cochera cocheraNueva(3);
        cocheraNueva[0] = coche1;
        cocheraNueva[1] = coche2;
        cocheraNueva[2] = coche3;
        mostrar_vector(cocheraNueva);
        std::cout << " +++ Agregaremos un coche +++\n";
        cocheraNueva.push_back(coche4);
        mostrar_vector(cocheraNueva);
        return 0;
}

Primero incluiremos tres librerias, siendo el primero nuestra habitual libreria. La segunda es para poder crear tipos string y el ultimo sera para los tipo vector. Lo siguiente es la definicion de una clase llamada Coche. En esta tendremos dos propiedades privadas para la marca y el modelo del mismo. En la parte publica tenemos dos constructores, siendo primero el constructor predeterminado e iniciara a las propiedades con datos «genericos». En cambio, el segundo si recibe dos valores y los usaremos para asignar a las propiedades. Luego tenemos dos metodos para recuperar los valores de las propiedades.

Despues haremos una sobrecarga sobre el operador << para los tipos de la clase anterior. En este caso cada vez que lo usemos nos mostraran los valores de las propiedades con un mensaje asociado. Para poder recibir cualquier objeto de esta clase usamos a rhs y a los metodos publicos de la clase.

Lo siguiente es el uso de una plantilla para una funcion. Esta funcion se encarga de mostrar el vector que le informemos. En este caso, usaremos algunas funciones propias de vector para poder obtener algunos datos. Veamos que hace cada uno de ellos:

• max_size(), encargada de mostrar el tamaño maximo disponible para el vector
• size(), encargada de mostrar el tamaño actual del vector
• capacity(), encargada de mostrar la capacidad del vector
• empty(), esta se encarga de definir si el vector tiene contenido o no por medio de chequeo simple ya que devuelve un booleano

Y finalmente, tenemos un bucle donde pasaremos por todo el vector y mostraremos la informacion contenida en el mismo. Aqui entra en accion la sobrecarga que hicimos anteriorrmente. Luego tenemos un typedef para crear un alias del tipo vector < Coche > y a partir de ahora podremos llamarlo como Cochera.

En el main, primero crearemos un objeto de tipo Coche con el constructor predeterminado. Para luego crear tres objetos nuevos con sus respectivos valores. Lo siguiente es crear un nuevo objeto del alias que creamos anteriormente. Este sera vacio y usaremos a la funcion para mostrar vectores que definimos anteriormente. Indicamos que creamos una nueva cochera, procedemos a crear con la capacidad para almacenar tres elementos. Para luego, agregar tres elementos a este nuevo objeto. Y, nuevamente llamar a mostrar_vector para ver al nuevo vector. Para finalmente, agregar un nuevo objeto en Cochera mediante la funcion push_back y nuevamente llamar a mostrar_vector para ver los nuevos cambios. Compilemos y veamos como es la salida:

$ ./stl
max_size(): 144115188075855871  size(): 0       capacity(): 0   vacio
 +++ Nueva cochera +++
max_size(): 144115188075855871  size(): 3       capacity(): 3   no vacio
Su marca es Generica y el modelo es Generico
Su marca es VW y el modelo es GOL
Su marca es FORD y el modelo es ECOSPORT
 +++ Agregaremos un coche +++
max_size(): 144115188075855871  size(): 4       capacity(): 6   no vacio
Su marca es Generica y el modelo es Generico
Su marca es VW y el modelo es GOL
Su marca es FORD y el modelo es ECOSPORT
Su marca es AUDI y el modelo es Q3
$

Observen como cada vector tiene sus propias propiedades. Siendo en el primer caso donde no solamente no tenemos ningun tamaño o capacidad sino que tambien lo podemos considerar vacio. En cambio, para los siguientes casos no solamente no estaran vacios sino que tendremos otros detalles. En el segundo caso tenemos un tamaño y una capacidad iguales porque en este caso establecimos ese tamaño y agregamos la misma cantidad de elementos. En el tercer caso, como usamos a push_back este no solamente agrego un nuevo valor, por esta razon tenemos un tamaño de 4 sino que tambien modifico la capacidad para poder agregar mas elementos al vector, siempre se modificara la capacidad cada vez que usemos a push_back para evitar quedarnos sin posibilidad de seguir agregando. Esta particularidad la pone por arriba de un array dado que nos da la posibilidad de tener un arrray dinamico. Antes de finalizar les dejo los otros metodos disponibles para manipular en vector:

• front(), devuelve el primer valor del vector
• back(), devuelve el ultimo valor del vector
• push_front(objeto), agrega un elemento al inicio del vector
• push_back(objeto), agrega un elemento al final del vector
• pop_front(), elimina el primer elemento de un vector y disminuye la capacidad en 1
• pop_back(), elimina el ulttimo elemento de un vector y disminuye la capacidad en 1
• insert(pos_iter, num_copias, valor), inserta un elemento en el vector. El primer argumento indica en que posicion, el segundo la cantidad de copias, y el ultimo el valor a agregar
• begin(), devuelve un iterador que apunta a la primera posicion del vector
• end(), devuelve un iterador que apunta a la ultima posicion del vector

En resumen, hoy hemos visto a vector, que es, para que sirve, como se utiliza, como se habilita, y un ejemplo practico para verlo en accion. Espero les haya resultado de utilidad sigueme en tumblr, Twitter o Facebook para recibir una notificacion cada vez que subo un nuevo post en este blog, nos vemos en el proximo post.