Cómo utilizar C ++ Vector

How Use 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 la mena y reducir su longitud. Un vector es como una matriz, pero su longitud se puede aumentar o reducir. Por tanto, un vector 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 contenedora. Un contenedor es una colección de objetos y se pueden realizar determinadas operaciones 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. Se trata de colecciones diferentes (estructuras de datos en forma de matriz) y cada una ofrece distintas ventajas y desventajas.







Cualquier programador debería 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, no se debe utilizar la matriz ordinaria.



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 utilizar 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 pertenezca a una clase para crear una instancia de 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 debe incluirse 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

En tfoo[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 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:

horas::vector <En t>vtr(8);

Aquí, el vector es de la función constructora especial. El tipo de datos que contendrá el vector es int, entre paréntesis 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 usar 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;

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 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:

nombre del vector

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

vector<flotador>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<flotador>vtr(4);

nombre del vector (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<flotador>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<flotador>vtr= {1.1, 2.2, 3.3, 4.4};

O

vector<flotador>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 se muestra a continuación:

vector<flotador>vtr({1.1, 2.2, 3.3, 4.4});

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

vector<flotador>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<flotador>vtr1(5, 3.4);
vector<flotador>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<flotador>vtr1{1.1, 2.2, 3.3, 4.4};
vector<flotador>vtr2=vtr1;

La segunda declaración es equivalente a:

vector<flotador>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:

constantevector<flotador>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<clase InputIterator>
vector(InputIterator primero,InputIterator último,constanteAsignador& =Asignador());

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 déjelo salir 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<flotador>vtr(4);
En ten uno=vtr.capacidad();
costo<<en uno<< ' orte';

La salida es 4.

reserva (n)

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

vector<flotador>vtr(4);
vtr.reserva(6);
costo<<vtr.capacidad() << ' orte';

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 del vector. El siguiente código ilustra esta función:

vector<flotador>vtr(4);
flotadors=vtr.Talla();
costo<<s<< ' orte';

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<flotador>vtr(4);
vtr.reserva(6);
vtr.encoger_para_ajustar();
En ts=vtr.Talla();
costo<<s<< ' orte';

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

redimensionar (sz), redimensionar (sz, c)

Esto cambia el tamaño del vector. Si el tamaño nuevo es más pequeño que el tamaño anterior, se borran los elementos hacia el final. 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<flotador>vtr1{1.1, 2.2, 3.3, 4.4};
vtr1.cambiar el tamaño(2);
costo<< 'Nuevo tamaño de vtr1:' <<vtr1.Talla() << ' orte';
vector<flotador>vtr2{1.1, 2.2};
vtr2.cambiar el tamaño(4, 8.8);
costo<< 'vtr2:'<<vtr2[0] <<' '<<vtr2[1] <<'
'
<<vtr2[2] <<' '<<vtr2[3] << ' orte';

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<flotador>vtr;
costo<<vtr.vacío() << ' orte';
vector<flotador>Vermont(4);
costo<<así que esovacío() << ' orte';

vector<flotador>v(4,3.5);
costo<<v.vacío() << ' orte';

El resultado es el siguiente:

1
0
0

Acceso a elementos vectoriales

Un vector puede tener sub-secuencias de comandos (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 ithíndice del vector. El siguiente código genera 3.3 para el vector anterior:

vector<flotador>vtr{1.1, 2.2, 3.3, 4.4};
flotadorFlorida=vtr[2];
costo<<Florida<< ' orte';

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:

constantevector<flotador>vtr{1.1, 2.2, 3.3, 4.4};
flotadorFlorida=vtr[2];
costo<<Florida<< ' orte';

La expresión devuelve una referencia constante a la ithelemento del vector.

Asignar un valor con subíndice

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

vector<flotador>vtr{1.1, 2.2, 3.3, 4.4};
vtr[2] = 8.8;
costo<<vtr[2] << ' orte';

La salida es 8.8.

vectorName.at (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<flotador>vtr{1.1, 2.2, 3.3, 4.4};
flotadorFlorida=vtr.a(2);
costo<<Florida<< ' orte';
a()es un miembro de vectorfunción.

vectorName.at (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:

constantevector<flotador>vtr{1.1, 2.2, 3.3, 4.4};
flotadorFlorida=vtr.a(2);
costo<<Florida<< ' orte';
a() constantees un miembro de vectorfunción.

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<flotador>vtr{1.1, 2.2, 3.3, 4.4};
vtr.a(2) = 8.8;
costo<<vtr[2] << ' orte';

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. El resultado del siguiente código es 1.1.

vector<flotador>vtr{1.1, 2.2, 3.3, 4.4};
flotadorFlorida=vtr.parte delantera();
costo<<Florida<< ' orte';

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:

constantevector<flotador>vtr{1.1, 2.2, 3.3, 4.4};
flotadorFlorida=vtr.parte delantera();
costo<<Florida<< ' orte';

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. El resultado del siguiente código es 4.4.

vector<flotador>vtr{1.1, 2.2, 3.3, 4.4};
flotadorFlorida=vtr.espalda();
costo<<Florida<< ' orte';

atrás () const

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

constantevector<flotador>vtr{1.1, 2.2, 3.3, 4.4};
flotadorFlorida=vtr.espalda();
costo<<Florida<< ' orte';

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 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 funciones 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<flotador>vtr{1.1, 2.2, 3.3, 4.4};
vector<flotador>::iteradoriter=vtr.empezar();
costo<< *iter<< ' orte';

La salida es 1.1. Tenga en cuenta que se ha declarado la declaración que recibe el iterador. 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 const, se ejecuta la expresión begin () const 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:

constantevector<flotador>vtr{1.1, 2.2, 3.3, 4.4};
vector<flotador>::const_iteratoriter=vtr.empezar();
costo<< *iter<< ' orte';

La salida es 1.1. Tenga en cuenta que esta vez se ha utilizado const_iterator en lugar de solo iterador 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<flotador>vtr{1.1, 2.2, 3.3, 4.4};
vector<flotador>::iteradoriter=vtr.fin();
costo<< *iter<< ' orte';

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:

constantevector<flotador>vtr{1.1, 2.2, 3.3, 4.4};
vector<flotador>::const_iteratoriter=vtr.fin();
costo<< *iter<< ' orte';

La salida es 0. Tenga en cuenta que esta vez se ha utilizado const_iterator en lugar de solo iterador 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<flotador>vtr{1.1, 2.2, 3.3, 4.4};
vector<flotador>::reverse_iteratorrIter=vtr.rbegin();
costo<< *rIter<< ' orte';

La salida es 4.4.

Tenga en cuenta que se ha declarado la declaración que recibe el iterador inverso. 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 (). En esta condición, el elemento correspondiente en el vector no se puede modificar. Esta función se utiliza en el siguiente código:

constantevector<flotador>vtr{1.1, 2.2, 3.3, 4.4};
vector<flotador>::const_reverse_iteratorrIter=vtr.rbegin();
costo<< *rIter<< ' orte';

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.

render () no excepto

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

vector<flotador>vtr{1.1, 2.2, 3.3, 4.4};
vector<flotador>::reverse_iteratorrIter=vtr.marcas();
costo<< *rIter<< ' orte';

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

render () const noexcept

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:

constantevector<flotador>vtr{1.1, 2.2, 3.3, 4.4};
vector<flotador>::const_reverse_iteratorrIter=vtr.marcas();
costo<< *rIter<< ' orte';

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.emplace (p, argumentos)

Inserta un objeto de tipo T construido con std :: forward (args)… 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<En t>vtr{10, 20, 30, 40};
vector<En t>::iteradoriter=vtr.empezar();
++iter;
++iter;
vtr.insertar(iter, 25);
costo<<vtr[1] << ' ' <<vtr[2]<< '
'
<<vtr[3] << ' orte';

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<En t>vtr{10, 20, 30, 40};
vector<En t>::iteradoriter=vtr.empezar();
++iter;
++iter;
vtr.insertar(iter, {25, 28});

costo<<vtr[1] << ' ' <<vtr[2]<< '
'
<<vtr[3]<< ' ' <<vtr[4] << ' orte';

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<En t>vtr{10, 20, 30, 40};
vector<En t>::iteradoriter=vtr.empezar();
++iter;
++iter;
vtr.borrar(iter);
costo<<vtr[0] << ' ' <<vtr[1] << '
'
<<vtr[2]<< ' orte';

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<flotador>vtr{1.1, 2.2, 3.3, 4.4};
vtr.hacer retroceder(5.5);
flotadorFlorida=vtr[4];
costo<<Florida<< ' orte';

La salida es 5,5.

hacer retroceder(rv): -te veo despues.

pop_back ()

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

vector<flotador>vtr{1.1, 2.2, 3.3, 4.4};
vtr.pop_back();
flotadors=vtr.Talla();
costo<<s<< ' orte';

La salida es 3.

cambiar (b)

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

vector<flotador>vtr1{1.1, 2.2, 3.3, 4.4};
vector<flotador>vtr2{10, 20};
vtr1.intercambio(vtr2);
costo<< 'vtr1:'<<vtr1[0] <<' '<<vtr1[1] <<'
'
<<vtr1[2] <<' '<<vtr1[3] << ' orte';

costo<< 'vtr2:'<<vtr2[0] <<' '<<vtr2[1] <<'
'
<<vtr2[2] <<' '<<vtr2[3] << ' orte';

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<flotador>vtr{1.1, 2.2, 3.3, 4.4};
vtr.claro();
costo<<vtr.Talla() << ' orte';

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<En t>U{1, 2, 3};
vector<En t>V{4, 5, 6};
bool bl=U==V;
costo<<licenciado en Derecho<< ' orte';

La salida es 0.

El! = 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<En t>U{1, 2, 3};
vector<En t>V{4, 5, 6};
bool bl=U!=V;
costo<<licenciado en Derecho<< ' orte';

La salida es 1.

los

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<En t>U{3, 1, 1};
vector<En t>V{3, 2, 1};
bool bl=U<V;
costo<<licenciado en Derecho<< ' orte';

La salida es 1.

El> operador

¡Vuelve! (U

los<= Operator

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

El> = operador

¡Vuelve! (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 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.