Cómo utilizar C ++ Vector

Introducción

Una matriz es una serie de los mismos tipos de objetos en ubicaciones de memoria consecutivas. Una matriz no puede aumentar el mineral reducir su longitud. Un vector es como una matriz, pero su longitud se puede aumentar o reducir. Un vector, por tanto, tiene muchas más operaciones que una matriz.

C ++ tiene muchas bibliotecas, todas las cuales forman la biblioteca estándar de C ++. Una de estas bibliotecas es la biblioteca de contenedores. Un contenedor es una colección de objetos y ciertas operaciones se pueden realizar en la colección. Los contenedores de C ++ se pueden agrupar en dos conjuntos: contenedores de secuencia y contenedores asociativos. Los contenedores de secuencia son vector, array (no el mismo array discutido anteriormente), deque, forward_list y list. Estas son colecciones diferentes (estructuras de datos similares a matrices) y cada una ofrece distintas compensaciones.

Cualquier programador debe saber cómo decidir si usar un vector, una matriz, una deque, un forward_list o una lista. Cuando un programador necesita una estructura que requiere más operaciones que las asociadas con una matriz ordinaria, la matriz ordinaria no debe usarse.

Si la tarea implica inserciones y eliminaciones frecuentes en el medio de la secuencia, entonces se debe usar una lista o lista_enviar. Si la tarea implica inserciones y eliminaciones frecuentes al principio o al final de una secuencia, se debe utilizar una deque. Se debe utilizar un vector cuando no se requieran este tipo de operaciones.

Este artículo le muestra cómo usar el vector C ++. Necesitará algunos conocimientos de punteros, referencias y matrices de C ++ para comprender este artículo.

Clase y objetos

Una clase es un conjunto de variables y funciones que trabajan juntas, donde las variables no tienen valores asignados. Cuando se asignan valores a las variables, una clase se convierte en un objeto. Diferentes valores dados a la misma clase dan como resultado diferentes objetos; es decir, diferentes objetos pueden ser de la misma clase pero tener diferentes valores. La creación de un objeto a partir de una clase también se conoce como instanciar el objeto.

El término vector describe una clase. Un objeto creado a partir de un vector tiene un nombre elegido por el programador.

Se necesita una función que pertenece a una clase para instanciar un objeto de la clase. En C ++, esa función tiene el mismo nombre que el nombre de la clase. Los diferentes objetos creados (instanciados) a partir de la clase tienen nombres distintos que el programador les da a cada uno de ellos.

Crear un objeto a partir de una clase significa construir el objeto; también significa instanciar el objeto.

La clase vectorial

La clase de vector ya se ha definido y está en la biblioteca. Para usar la clase de vector, un programador debe incluir el encabezado de vector en el archivo con la siguiente directiva de preprocesamiento:

#incluir

Una vez que se incluye el encabezado, todas las características vectoriales (miembros de datos y funciones de miembros) se vuelven accesibles. Para utilizar el objeto de recuento para enviar datos al terminal (consola), también se debe incluir el encabezado del objeto. Para escribir un programa con el vector, como mínimo, se deben incluir los siguientes encabezados:

#incluir
#incluir

Creación de instancias de un vector

int foo [10];

Arriba está la declaración de una matriz con el nombre "foo" y el número de elementos "10."Esta es una matriz de números enteros. La declaración de un vector es similar. Para un vector, el número de elementos es opcional, ya que la longitud del vector puede aumentar o disminuir.

En este punto del programa, la clase de vector ya se ha definido en la biblioteca y se ha incluido el encabezado. El vector se puede instanciar de la siguiente manera:

std :: vector vtr (8);

Aquí, el vector es de la función constructora especial. El tipo de datos que contendrá el vector es "int", entre corchetes angulares. El término "vtr" es el nombre elegido por el programador para el vector. Finalmente, "8", entre paréntesis, es el número tentativo de enteros que tendrá el vector.

El término "std" significa espacio de nombres estándar. Este término debe ir seguido de dos puntos dobles, en este contexto. Cualquiera puede escribir su propia biblioteca de clases de vectores y usarla. Sin embargo, C ++ ya tiene una biblioteca estándar con nombres estándar, incluido "vector.”Para utilizar un nombre estándar, el nombre estándar debe estar precedido por std :: . Para evitar escribir std :: cada vez en el programa para un nombre estándar, el archivo del programa puede iniciarse de la siguiente manera:

#incluir
#incluir
usando el espacio de nombres std;

Sobrecarga de una función

Cuando dos o más firmas de funciones diferentes tienen el mismo nombre, se dice que ese nombre está sobrecargado. Cuando se llama a una función, el número y el tipo de argumentos determinan qué función se ejecuta.

Construyendo un Vector

Construir un vector significa instanciar (crear) un objeto vectorial. La función constructora se sobrecarga de la siguiente manera:

vector nombre

Esto crea un vector de longitud cero y escribe "T."La siguiente declaración crea un vector de longitud cero del tipo" float "con el nombre" vtr: "

vector vtr;

vector nombre (n)

Esto crea un vector con n elementos de tipo "T.”Una declaración para este vector con cuatro elementos flotantes es la siguiente:

vector vtr (4);

vector nombre (n, t)

Esto crea un vector de n elementos inicializados al valor t. La siguiente declaración crea un vector de 5 elementos, donde cada elemento tiene el valor 3.4:

vector vtr (5, 3.4);

Construir con inicialización

Un vector se puede construir (crear) e inicializar al mismo tiempo, de una de las dos formas siguientes:

vector vtr = 1.1, 2.2, 3.3, 4.4;

vector vtr 1.1, 2.2, 3.3, 4.4;

Tenga en cuenta que no hay paréntesis justo después del nombre del objeto. Los paréntesis usados justo después del nombre del objeto deben tener la lista de inicializadores, como sigue:

vector vtr (1.1, 2.2, 3.3, 4.4);

Se puede construir e inicializar un vector más tarde con la lista de inicializadores. En este caso, no se utilizarán los paréntesis:

vector vtr;
vtr = 1.1, 2.2, 3.3, 4.4;

vector V2 (V1)

Este es un constructor de copias. Crea un vector V2 como una copia del vector V1. El siguiente código ilustra esto:

vector vtr1 (5, 3.4);
vector vtr2 (vtr1);

Asignar un vector durante la construcción

Durante la construcción, se puede crear un vector vacío mientras se le asigna otro, de la siguiente manera:

vector vtr1 1.1, 2.2, 3.3, 4.4;
vector vtr2 = vtr1;

La segunda declaración es equivalente a:

vector vtr2 = 1.1, 2.2, 3.3, 4.4;

vector const

Un vector constante es un vector cuyos elementos no se pueden cambiar. Los valores de este vector son de solo lectura. Cuando se crea, el vector aparece de la siguiente manera:

vector constante vtr 1.1, 2.2, 3.3, 4.4;

En este tipo de vector, no se puede agregar ni quitar ningún elemento. Además, no se puede cambiar ningún valor.

Construir con iterador

Una plantilla proporciona una representación genérica de un tipo de datos. Un iterador proporciona una representación genérica del escaneo a través de los valores de un contenedor. La sintaxis para crear un vector con un iterador es la siguiente:

plantilla
vector (InputIterator primero, InputIterator último, const Allocator & = Allocator ());

Esto construye un vector para el rango [primero, último) usando el asignador especificado, que se discutirá más adelante en este artículo.

Destruir un vector

Para destruir un vector, simplemente permita que salga del alcance y la destrucción se maneja automáticamente.

Capacidad vectorial

size_type capacidad () const noexcepto

La función de miembro de capacidad devuelve el número total de elementos que el vector puede contener sin necesidad de reasignación. Un segmento de código para esto es el siguiente:

vector vtr (4);
int num = vtr.capacidad();
cout << num << '\n';

La salida es 4.

reserva (n)

El espacio de memoria no siempre está disponible gratuitamente. Se puede reservar espacio adicional con anticipación. Considere el siguiente segmento de código:

vector vtr (4);
vtr.reserva (6);
cout << vtr.capacity() << '\n';

La salida es 6. Entonces, el espacio extra reservado es 6 - 4 = 2 elementos. La función devuelve vacío.

tamaño () const no excepto

Esto devuelve el número de elementos en el vector. El siguiente código ilustra esta función:

vector vtr (4);
flotar sz = vtr.Talla();
cout << sz << '\n';

La salida es 4.

encoger_para_ajustar ()

Después de dar capacidad adicional a un vector con la función reserve (), el vector se puede reducir para que se ajuste a su tamaño original. El siguiente código ilustra esto:

vector vtr (4);
vtr.reserva (6);
vtr.encoger_para_ajustar ();
int sz = vtr.Talla();
cout << sz << '\n';

La salida es 4 y no 6. La función devuelve vacío.

redimensionar (sz), redimensionar (sz, c)

Esto cambia el tamaño del vector. Si el nuevo tamaño es más pequeño que el tamaño anterior, los elementos hacia el final se borran. Si el nuevo tamaño es más largo, se agrega algún valor predeterminado hacia el final. Para tener un valor agregado particular, use la función resize () con dos argumentos. El siguiente segmento de código ilustra el uso de estas dos funciones:

vector vtr1 1.1, 2.2, 3.3, 4.4;
vtr1.cambiar el tamaño (2);
cout << "New size of vtr1: " << vtr1.size() << '\n';
vector vtr2 1.1, 2.2;
vtr2.cambiar el tamaño (4, 8.8);
cout << "vtr2: "<< vtr2[0] <<" "<< vtr2[1] <<"
"<< vtr2[2] <<" "<< vtr2[3] << '\n';

El resultado es el siguiente:

Nuevo tamaño de vtr1: 2
vtr2: 1.1 2.2 8.8 8.8

Las funciones vuelven nulas.

vacío () const no excepto

Esta función devuelve 1 para verdadero si no hay elementos en el vector y 0 para falso si el vector está vacío. Si un vector tiene 4 ubicaciones para un tipo particular de datos, como flotante, sin ningún valor flotante, entonces ese vector no está vacío. El siguiente código ilustra esto:

vector vtr;
cout << vtr.empty() << '\n';
vector vt (4);
cout << vt.empty() << '\n';
vector v (4,3.5);
cout << v.empty() << '\n';

El resultado es el siguiente:

1
0
0

Acceso a elementos vectoriales

Un vector puede ser subcriptado (indexado) como una matriz. El recuento de índices comienza desde cero.

vectorName [i]

La operación "vectorName [i]" devuelve una referencia al elemento en la i^th índice del vector. El siguiente código genera 3.3 para el vector anterior:

vector vtr 1.1, 2.2, 3.3, 4.4;
flotador fl = vtr [2];
cout << fl << '\n';

vectorName [i] const

La operación "vectorName [i] const" se ejecuta en lugar de "vectorName [i]" cuando el vector es un vector constante. Esta operación se utiliza en el siguiente código:

vector constante vtr 1.1, 2.2, 3.3, 4.4;
flotador fl = vtr [2];
cout << fl << '\n';

La expresión devuelve una referencia constante a la i^th elemento del vector.

Asignar un valor con subíndice

Se puede asignar un valor a un vector no constante, de la siguiente manera:

vector vtr 1.1, 2.2, 3.3, 4.4;
vtr [2] = 8.8;
cout << vtr[2] << '\n';

La salida es 8.8.

vectorName.en (i)

"VectorName.at (i) "es como" vectorName [i] ", pero" vectorName.at (i) ”es más confiable. El siguiente código muestra cómo se debe usar este vector:

vector vtr 1.1, 2.2, 3.3, 4.4;
flotador fl = vtr.a las 2);
cout << fl << '\n';
at () es una función miembro de vector.

vectorName.en (i) const

"VectorName.at (i) const ”es como“ vectorName [i] const ”, pero“ vectorName.at (i) const ”es más confiable. "VectorName.at (i) const ”se ejecuta en lugar de“ vectorName.at (i) ”cuando el vector es un vector constante. Este vector se utiliza en el siguiente código:

vector constante vtr 1.1, 2.2, 3.3, 4.4;
flotador fl = vtr.a las 2);
cout << fl << '\n';
at () const es una función miembro de vector.

Asignar un valor con la función at ()

Se puede asignar un valor a un vector no constante con la función at (), de la siguiente manera:

vector vtr 1.1, 2.2, 3.3, 4.4;
vtr.en (2) = 8.8;
cout << vtr[2] << '\n';

La salida es 8.8.

Problema con las secuencias de comandos secundarias

El problema con el sub-scripting (indexación) es que si el índice está fuera de rango, se puede devolver cero o se puede emitir un error en tiempo de ejecución.

parte delantera()

Esto devuelve una referencia al primer elemento del vector sin eliminar el elemento. La salida del siguiente código es 1.1.

vector vtr 1.1, 2.2, 3.3, 4.4;
flotador fl = vtr.parte delantera();
cout << fl << '\n';

El elemento no se elimina del vector.

frente () const

Cuando la construcción del vector está precedida por const, se ejecuta la expresión "front () const" en lugar de "front ().”Esto se usa en el siguiente código:

vector constante vtr 1.1, 2.2, 3.3, 4.4;
flotador fl = vtr.parte delantera();
cout << fl << '\n';

Se devuelve una referencia constante. El elemento no se elimina del vector.

espalda()

Esto devuelve una referencia al último elemento del vector sin eliminar el elemento. La salida del siguiente código es 4.4.

vector vtr 1.1, 2.2, 3.3, 4.4;
flotador fl = vtr.espalda();
cout << fl << '\n';

atrás () const

Cuando la construcción del vector está precedida por una constante, se ejecuta la expresión "back () const" en lugar de "back ().”Esto se usa en el siguiente código:

vector constante vtr 1.1, 2.2, 3.3, 4.4;
flotador fl = vtr.espalda();
cout << fl << '\n';

Se devuelve una referencia constante. El elemento no se elimina del vector.

Acceso a datos vectoriales

datos () no excepto; data () const noexcept;

Cualquiera de estos devuelve un puntero tal que [data (), data () + size ()) es un rango válido.

Esto se tratará con más detalle más adelante en el artículo.

Iteradores que regresan y el vector

Un iterador es como un puntero pero tiene más funcionalidad que un puntero.

comenzar () no excepto

Devuelve un iterador que apunta al primer elemento del vector, como en el siguiente segmento de código:

vector vtr 1.1, 2.2, 3.3, 4.4;
vector:: iterador iter = vtr.empezar();
cout << *iter << '\n';

La salida es 1.1. Tenga en cuenta que la declaración que recibe el iterador ha sido declarada. El iterador se desreferencia en una expresión de retorno para obtener el valor de la misma manera que se desreferencia un puntero.

begin () const noexcept;

Devuelve un iterador que apunta al primer elemento del vector. Cuando la construcción del vector está precedida por una constante, se ejecuta la expresión "begin () const" en lugar de "begin ().”Bajo esta condición, el elemento correspondiente en el vector no se puede modificar. Esto se usa en el siguiente código:

vector constante vtr 1.1, 2.2, 3.3, 4.4;
vector:: const_iterator iter = vtr.empezar();
cout << *iter << '\n';

La salida es 1.1. Tenga en cuenta que esta vez se ha utilizado "const_iterator" en lugar de solo "iterator" para recibir el iterador devuelto.

fin () no excepto

Devuelve un iterador que apunta inmediatamente más allá del último elemento del vector. Considere el siguiente segmento de código:

vector vtr 1.1, 2.2, 3.3, 4.4;
vector:: iterador iter = vtr.final();
cout << *iter << '\n';

La salida es 0, lo cual no tiene sentido, ya que no hay ningún elemento concreto más allá del último elemento.

end () const no excepto

Devuelve un iterador que apunta inmediatamente más allá del último elemento del vector. Cuando la construcción del vector está precedida por "const", se ejecuta la expresión "end () const" en lugar de "end ().”Considere el siguiente segmento de código:

vector constante vtr 1.1, 2.2, 3.3, 4.4;
vector:: const_iterator iter = vtr.final();
cout << *iter << '\n';

La salida es 0. Tenga en cuenta que esta vez se ha utilizado "const_iterator" en lugar de solo "iterator" para recibir el iterador devuelto.

Iteración inversa

Es posible tener un iterador que itera desde el final hasta justo antes del primer elemento.

rbegin () no excepto

Devuelve un iterador que apunta al último elemento del vector, como en el siguiente segmento de código:

vector vtr 1.1, 2.2, 3.3, 4.4;
vector:: Reverse_iterator rIter = vtr.rbegin ();
cout << *rIter << '\n';

La salida es 4.4.

Tenga en cuenta que la declaración que recibe el iterador inverso ha sido declarada. El iterador se desreferencia en una expresión de retorno para obtener el valor de la misma manera que se desreferencia un puntero.

rbegin () const noexcept;

Devuelve un iterador que apunta al último elemento del vector. Cuando la construcción del vector está precedida por "const", se ejecuta la expresión "rbegin () const" en lugar de "rbegin ().”Bajo esta condición, el elemento correspondiente en el vector no se puede modificar. Esta función se utiliza en el siguiente código:

vector constante vtr 1.1, 2.2, 3.3, 4.4;
vector:: const_reverse_iterator rIter = vtr.rbegin ();
cout << *rIter << '\n';

La salida es 4.4.

Tenga en cuenta que esta vez se ha utilizado const_reverse_iterator, en lugar de solo reverse_iterator, para recibir el iterador devuelto.

rend () no excepto

Devuelve un iterador que apunta justo antes del primer elemento del vector. Considere el siguiente segmento de código:

vector vtr 1.1, 2.2, 3.3, 4.4;
vector:: Reverse_iterator rIter = vtr.desgarrar();
cout << *rIter << '\n';

La salida es 0, lo cual no tiene sentido, ya que no hay ningún elemento concreto justo antes del primer elemento.

rend () const no excepto

Devuelve un iterador que apunta justo antes del primer elemento del vector. Cuando la construcción del vector está precedida por "const", se ejecuta la expresión "rend () const" en lugar de "rend ().”Considere el siguiente segmento de código:

vector constante vtr 1.1, 2.2, 3.3, 4.4;
vector:: const_reverse_iterator rIter = vtr.desgarrar();
cout << *rIter << '\n';

La salida es 0.

Tenga en cuenta que esta vez se ha utilizado const_reverse_iterator, en lugar de solo reverse_iterator, para recibir el iterador devuelto.

Modificadores de vectores

Un modificador que modifica el vector puede tomar o devolver un iterador.

a.emplazamiento (p, argumentos)

Inserta un objeto de tipo T construido con std :: forward(argumentos)… antes de p.

Para obtener más detalles, ver más adelante

insert (iteratorPosition, valor)

Inserta una copia del valor en la posición del iterador del vector. Devuelve el iterador (posición) en el vector donde se ha colocado la copia. El siguiente código muestra dónde se ha colocado el valor:

vector vtr 10, 20, 30, 40;
vector:: iterador iter = vtr.empezar();
++iter;
++iter;
vtr.insertar (iter, 25);
cout << vtr[1] << " << vtr[2]<< '
' << vtr[3] << '\n';

La salida es: 20 25 30.

Tenga en cuenta que el iterador se avanzó (incrementó) como un puntero.

También se puede insertar una lista de inicializadores, como lo ilustra el siguiente código:

vector vtr 10, 20, 30, 40;
vector:: iterador iter = vtr.empezar();
++iter;
++iter;
vtr.insertar (iter, 25, 28);
cout << vtr[1] << " << vtr[2]<< '
' << vtr[3]<< " << vtr[4] << '\n';

La salida es: 20 25 28 30.

borrar (posición)

Elimina un elemento en la posición apuntada por el iterador, luego devuelve la posición del iterador. El siguiente código ilustra esto:

vector vtr 10, 20, 30, 40;
vector:: iterador iter = vtr.empezar();
++iter;
++iter;
vtr.borrar (iter);
cout << vtr[0] << " << vtr[1] << '
' << vtr[2]<< '\n';

La salida es: 10 20 40

retroceso (t), retroceso (rv)

Se usa para agregar un solo elemento al final del vector. Utilice push_back (t) de la siguiente manera:

vector vtr 1.1, 2.2, 3.3, 4.4;
vtr.retroceso (5.5);
flotador fl = vtr [4];
cout << fl << '\n';

La salida es 5.5.

push_back (rv): - ver más adelante.

pop_back ()

Elimina el último elemento sin devolverlo. El tamaño del vector se reduce en 1. El siguiente código ilustra esto:

vector vtr 1.1, 2.2, 3.3, 4.4;
vtr.pop_back ();
flotar sz = vtr.Talla();
cout << sz << '\n';

La salida es 3.

a.permuta (b)

Se pueden intercambiar dos vectores, como se ilustra en el siguiente segmento de código:

vector vtr1 1.1, 2.2, 3.3, 4.4;
vector vtr2 10, 20;
vtr1.intercambio (vtr2);
cout << "vtr1: "<< vtr1[0] <<" "<< vtr1[1] <<"
"<< vtr1[2] <<" "<< vtr1[3] << '\n';
cout << "vtr2: "<< vtr2[0] <<" "<< vtr2[1] <<"
"<< vtr2[2] <<" "<< vtr2[3] << '\n';

La salida es:

vtr1: 10 20 0 0
vtr2: 1.1 2.2 3.3 4.4

Tenga en cuenta que la longitud de un vector aumenta, si es necesario. Además, los valores que no tenían reemplazos se reemplazan por algún valor predeterminado.

claro()

Elimina todos los elementos del vector, como lo ilustra el siguiente segmento de código:

vector vtr 1.1, 2.2, 3.3, 4.4;
vtr.claro();
cout << vtr.size() << '\n';

La salida es 0.

Operadores relacionales y de igualdad para vectores

El == operador

Devuelve 1 por verdadero si los dos vectores tienen el mismo tamaño y los elementos correspondientes son iguales; de lo contrario, devuelve 0 para falso. Por ejemplo:

vector U 1, 2, 3;
vector V 4, 5, 6;
bool bl = U == V;
cout << bl << '\n';

La salida es 0.

La != Operador

Devuelve 1 por verdadero si los dos vectores no tienen el mismo tamaño y / o los elementos correspondientes no son iguales; de lo contrario, devuelve 0 para falso. Por ejemplo:

vector U 1, 2, 3;
vector V 4, 5, 6;
bool bl = U!= V;
cout << bl << '\n';

La salida es 1.

La < Operator

Devuelve 1 para verdadero si el primer vector es el subconjunto inicial del segundo vector, con los elementos de las dos porciones iguales siendo iguales y en el mismo orden. Si ambos vectores son del mismo tamaño y se mueven de izquierda a derecha y se encuentra un elemento en el primer vector que es menor que el elemento correspondiente en el segundo vector, entonces se devolverá 1. De lo contrario, se devuelve 0 para falso. Por ejemplo:

vector U 3, 1, 1;
vector V 3, 2, 1;
bool bl = Ucout << bl << '\n';

La salida es 1. < does not include the case when the size and order are the same.

El> operador

Devoluciones !(U < V), where U is the first vector and V is the second vector, according to the above definitions.

La <= Operator

Devuelve U <= V, where U is the first vector and V is the second vector, according to the above definitions.

El> = operador

Devoluciones !(U <= V), where U is the first vector and V is the second vector, according to the above definitions.

Conclusión

Un vector es un ejemplo de un contenedor de secuencia. Un vector es una forma "mejor" de la matriz ordinaria y se crea una instancia de una clase. Los vectores tienen métodos que se clasifican en: construcción y asignación, capacidad, acceso a elementos, acceso a datos, iteradores, modificadores y operadores numéricos sobrecargados.

Hay otros contenedores de secuencia, llamados list, forward_list y array. Si la tarea implica inserciones y eliminaciones frecuentes en el medio de la secuencia, entonces se debe usar una lista o lista_enviar. Si la tarea implica inserciones y eliminaciones frecuentes al principio o al final de la secuencia, se debe utilizar una deque. Por lo tanto, los vectores deben usarse solo cuando este tipo de operaciones no son importantes.