Cómo usar C ++ Vector

Una matriz es una serie de los mismos tipos de objetos en ubicaciones de memoria consecutivas. Una matriz no puede aumentar el mineral reducido de longitud. Un vector es como una matriz, pero su longitud se puede aumentar o reducir. Un vector, por lo tanto, tiene muchas más operaciones que una matriz. C ++ tiene muchas bibliotecas, todas las cuales forman la biblioteca estándar 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 C ++ se pueden agrupar en dos conjuntos: contenedores de secuencia y contenedores asociativos. Los contenedores de secuencia son vectoriales, matriz (no la misma matriz discutida anteriormente), Deque, Forward_list y List. Estas son diferentes colecciones (estructuras de datos similares a la matriz), y cada una ofrece distintas compensaciones. Cualquier programador debe saber cómo decidir si usar un vector, una matriz, un deque, un reward_list o una lista. Cuando un programador necesita una estructura que requiera más operaciones que las asociadas con una matriz ordinaria, la matriz ordinaria no debe usarse. Si la tarea implica inserciones y deleciones frecuentes en el medio de la secuencia, entonces se debe usar una lista o reenviar_list. Si la tarea implica inserciones y deleciones frecuentes al principio o al final de una secuencia, entonces se debe usar un deque. Se debe usar un vector cuando no se requieran este tipo de operaciones. Este artículo le muestra cómo usar el vector C ++. Necesitará algún conocimiento de los punteros, referencias y matrices de C ++ para comprender este artículo.

Clase y objetos

Una clase es un conjunto de variables y funciones que funcionan juntas, donde las variables no tienen valores asignados. Cuando los valores se asignan 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 tienen valores diferentes. Crear un objeto a partir de una clase también se conoce como instancia del 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. Diferentes objetos creados (instanciados) de la clase tienen nombres distintos dados a cada uno de ellos por el programador.

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 Vector, un programador debe incluir el encabezado vectorial 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 usar el objeto de recuento para salir de datos en el terminal (consola), el encabezado del objeto también debe incluirse. Para escribir un programa con el vector, como mínimo, se deben incluir los siguientes encabezados:

#incluir
#incluir

Instanciando 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 variedad de 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 Vector ya se ha definido en la biblioteca, y el encabezado ha sido incluido. El vector se puede instanciar de la siguiente manera:

std :: vector VTR (8);

Aquí, el vector es de la función de constructor especial. El tipo de datos que el vector sostendrá es "int", en los soportes de ángulo. 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 el vector tendrá.

El término "STD" significa espacio de nombres estándar. Este término debe ser seguido por un doble colon, en este contexto. Cualquiera puede escribir su propia biblioteca de clases vectoriales y usarla. Sin embargo, C ++ ya tiene una biblioteca estándar con nombres estándar, incluido "Vector."Para usar un nombre estándar, el nombre estándar debe ser precedido por std :: . Para evitar escribir std :: cada vez en el programa para un nombre estándar, el archivo del programa puede comenzar de la siguiente manera:

#incluir
#incluir
usando el espacio de nombres STD;

Sobrecargar 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 del constructor se sobrecarga de la siguiente manera:

nombre vectorial

Esto crea un vector de longitud cero y tipo "t."La siguiente declaración crea un vector de longitud cero del tipo" flotante "con el nombre" VTR: "

vector VTR;

nombre vectorial (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);

Nombre vectorial (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);

Construcción con inicialización

Se puede construir un vector (creado) e inicializarse al mismo tiempo, en una de las siguientes dos maneras:

vector vtr = 1.1, 2.2, 3.3, 4.4;

O

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. Paréntesis utilizados justo después de que el nombre del objeto debe tener la lista de inicializador, de la siguiente manera:

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

Un vector se puede construir e inicializarse más tarde con la lista de inicializador. 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);

Asignando 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 constante

Un vector constante es un vector cuyos elementos no se pueden cambiar. Los valores en 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 o eliminar ningún elemento. Además, no se puede cambiar ningún valor.

Construcción con iterador

Una plantilla proporciona una representación genérica para 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 el siguiente:

plantilla
vector (inputIterator First, InputIterator Last, const alocator & = Allocator ());

Esto construye un vector para el rango [primero, último) utilizando 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 destruya se maneja automáticamente.

Capacidad vectorial

size_type Capacidad () const Noexcept

El número total de elementos que el vector puede tener sin requerir la reasignación es devuelto por la función de miembro de la capacidad. 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. El espacio adicional se puede reservar por adelantado. Considere el siguiente segmento de código:

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

La salida es 6. Entonces, el espacio adicional reservado es 6 - 4 = 2 elementos. La función devuelve nulo.

size () const noexcept

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

vector VTR (4);
flotante sz = vtr.tamaño();
cout << sz << '\n';

La salida es 4.

Shrink_to_fit ()

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

vector VTR (4);
VTR.reserva (6);
VTR.Shrink_to_fit ();
int sz = vtr.tamaño();
cout << sz << '\n';

La salida es 4 y no 6. La función devuelve nulo.

cambiar el tamaño (SZ), cambiar el tamaño (SZ, C)

Esto cambia de tamaño al vector. Si el nuevo tamaño es más pequeño que el tamaño anterior, entonces se borran los elementos hacia el final. Si el nuevo tamaño es más largo, entonces 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';

La salida es la siguiente:

Nuevo tamaño de VTR1: 2
VTR2: 1.1 2.2 8.8 8.8

Las funciones devuelven nulo.

vacía () const noexcept

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 el flotador, 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';

La salida es la siguiente:

1
0
0

Acceso al elemento vectorial

Un vector se puede subriptar (indexado) como una matriz. El conteo de índice comienza desde cero.

vectorname [i]

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

vector VTR 1.1, 2.2, 3.3, 4.4;
flotante 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;
flotante fl = vtr [2];
cout << fl << '\n';

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

Asignación de un valor con subíndice

Se puede asignar un valor a un vector no constante, como sigue:

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.en (i) "es como" vectorname [i] ", pero" vectorname.en (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;
flotante fl = vtr.a las 2);
cout << fl << '\n';
at () es una función de miembro vectorial.

Vectorname.en (i) const

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

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

Asignando un valor con la función AT ()

Se puede asignar un valor a un vector no constante con la función AT (), como sigue:

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 la subcripción

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

frente()

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;
flotante fl = vtr.frente();
cout << fl << '\n';

El elemento no se elimina del vector.

front () const

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

vector constante VTR 1.1, 2.2, 3.3, 4.4;
flotante fl = vtr.frente();
cout << fl << '\n';

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

atrás()

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;
flotante fl = vtr.atrás();
cout << fl << '\n';

Atrás () const

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

vector constante VTR 1.1, 2.2, 3.3, 4.4;
flotante fl = vtr.atrás();
cout << fl << '\n';

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

Acceso a datos vectoriales

data () noexcept; data () const noexcept;

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

Esto se cubrirá con mayor 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.

begin () noexcept

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:: iterator iter = vtr.comenzar();
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 desactiva en una expresión de retorno para obtener el valor de la misma manera que un puntero se desactiva.

begin () const noexcept;

Devuelve un iterador que apunta al primer elemento del vector. Cuando la construcción del vector está precedida por const, la expresión "begin () const" se ejecuta en lugar de "begin ()."En 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.comenzar();
cout << *iter << '\n';

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

end () noexcept

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:: iterator iter = vtr.fin();
cout << *iter << '\n';

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

end () const noexcept

Devuelve un iterador que apunta inmediatamente más allá del último elemento del vector. Cuando la construcción del vector está precedida por "const", la expresión "end () const" se ejecuta 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.fin();
cout << *iter << '\n';

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

Iteración inversa

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

rbegin () Noexcept

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 desactiva en una expresión de retorno para obtener el valor de la misma manera que un puntero se desactiva.

rbegin () const noexcept;

Devuelve un iterador que apunta al último elemento del vector. Cuando la construcción del vector está precedida por "const", la expresión "rbegin () const" se ejecuta en lugar de "rbegin ()."En esta condición, el elemento correspondiente en el vector no se puede modificar. Esta característica se usa 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 el const_reverse_iterator se ha utilizado esta vez, en lugar de solo el reverso_iterator, para recibir el iterador devuelto.

rend () noexcept

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, que no tiene sentido, ya que no hay elemento concreto justo antes del primer elemento.

rend () const noexcept

Devuelve un iterador que apunta justo antes del primer elemento del vector. Cuando la construcción del vector está precedida por "const", la expresión "rend () const" se ejecuta 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 el const_reverse_iterator se ha utilizado esta vez, en lugar de solo el reverso_iterator, para recibir el iterador devuelto.

Modificadores vectoriales

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

a.Emplace (P, args)

Inserta un objeto de tipo t construido con std :: hacia adelante (args) ... antes de p.

Para más detalles - ver más tarde

insertar (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:: iterator iter = vtr.comenzar();
++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 fue avanzado (incrementado) al igual que un puntero.

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

vector VTR 10, 20, 30, 40;
vector:: iterator iter = vtr.comenzar();
++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 señalada por el iterador, luego devuelve la posición del iterador. El siguiente código ilustra esto:

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

La salida es: 10 20 40

push_back (t), push_back (rv)

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

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

La salida es 5.5.

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

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 ();
flotante sz = vtr.tamaño();
cout << sz << '\n';

La salida es 3.

a.intercambio (b)

Se pueden cambiar 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 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 de igualdad y relacionales para vectores

El operador ==

Devuelve 1 para 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.

El != Operador

Devuelve 1 para 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.

El < Operator

Devuelve 1 para verdadero si el primer vector es el subconjunto inicial del segundo vector, con los elementos de las dos porciones iguales son las mismas 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 1 aún se devolverá. 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.

El <= 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 instancia desde 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 sobrecargados numéricos.

Hay otros contenedores de secuencia, llamados List, Forward_list y Array. Si la tarea implica inserciones y deleciones frecuentes en el medio de la secuencia, entonces se debe usar una lista o reenviar_list. Si la tarea implica inserciones y deleciones frecuentes al principio o al final de la secuencia, entonces se debe usar un deque. Y así, los vectores deben usarse solo cuando este tipo de operaciones no son importantes.