¿Cómo se expande un vector en c?++?

Si "expandir" aquí significa incluir más elementos en el vector para que aumente su tamaño (longitud), entonces se puede ampliar un vector. Sin embargo, "expandir un vector" no es una frase clásica en C++. De hecho, "expandir" en C ++ en realidad significa, reemplazar el nombre de un objeto con los valores de su contenido.Si un vector consta de literales de cadena, entonces el vector puede ser reemplazado por una cadena compuesta por literales de cadena. Sin embargo, esto debe hacerse manualmente. Es decir, debe ser realizado por el programador y no por una biblioteca.

No obstante, esta publicación explicará cómo reemplazar un vector de literales de cadena, con una cadena de literales. Esta publicación también explicará las diferentes formas en que el vector C ++ puede aumentarse en longitud. La longitud de un vector en C ++ se llama el tamaño.

El vector tiene funciones miembros. Su tamaño se puede aumentar utilizando las funciones del miembro: resize (), insert (), emplace () y push_back (). Este artículo explica las diferentes formas en que se puede ampliar el vector, es decir, aumenta en tamaño; y en el caso del vector de literales de cadena, reemplazado por todos los literales de cadena.

Hacer codificación vectorial dentro del cuerpo de la función principal (), a menos que haya una buena razón para hacerlo antes del cuerpo de la función principal (). No olvide comenzar el programa con:

#incluir
#incluir
usando el espacio de nombres STD;

Contenido del artículo

• Vector de cuerdas, a una cadena
• Aumento del tamaño del vector
• Cambio de tamaño
• Inserción
• Emplárgico
• Hacer retroceder
• Conocer la longitud de un vector
• Capacidad de un vector
• Reservar espacio para vector
• Conclusión

Vector de cuerdas a una cadena

Un vector de literales de cadena puede ser reemplazado por una cadena de literales. Los literales estarán separados por comas en la única cadena. El siguiente código ilustra esto:

vectorvtr = "Toyota", "Mitsubishi", "Ford", "Mercedes", "Jeep";
Char Arrchars [100];
int ctr = 0; //encimera
int i = 0;
para (i = 0; iconst char* str = vtr [i];
int j = 0;
para (j = 0; str [j] != '\ 0'; j ++)
Arrchars [Ctr] = str [j];
++Ctr;

Arrchars [Ctr] = ','; ++ Ctr; Arrchars [Ctr] = ";
++Ctr;

Arrchars [Ctr] = '\ 0';
cout<La salida es:

Toyota, Mitsubishi, Ford, Mercedes, Jeep,

que es una cadena larga. Una cadena de matriz y una cadena literal en cotizaciones dobles, son fundamentalmente lo mismo, que terminan en '\ 0'; Aunque el final para la doble cita literal es implícito. La última cadena larga tiene solo un '\ 0' al final de la secuencia de caracteres. El código aún se puede modificar para eliminar la última coma y espacio.

Aumento del tamaño del vector

Cambio de tamaño

La función de miembro size () se puede usar para devolver el tamaño () de un vector como muestra el siguiente código:

vectorvtr 'f', 'g', 'h', 'i', 'j';
cout<La salida es 5.

Vacío de cambio de tamaño (size_type sz)

Para aumentar el tamaño de un vector, el vector debe cambiar el tamaño de un número mayor. El siguiente código hace esto utilizando la función miembro, cambiar el tamaño (size_type sz):

vectorvtr 'f', 'g', 'h', 'i', 'j';
VTR.cambiar el tamaño (7);
VTR [5] = 'K';
vtr [6] = 'l';
para (int i = 0; icout<
cout<La salida es:

F g h i j k l

Cuando un vector acaba de cambiar el tamaño con la función de miembro RESISE (), se ponen a disposición nuevas ubicaciones vacías para el final del vector. Estas nuevas ubicaciones se pueden llenar.

Vacío de cambio de tamaño (size_type sz, const t&c)

El mismo valor se puede agregar a las nuevas ubicaciones hacia el final del vector utilizando este método sobrecargado de reizal (). Ilustración:

vectorvtr 'f', 'g', 'h', 'i', 'j';
VTR.cambiar el tamaño (8, 'z');
para (int i = 0; icout<
cout<La salida es:

F G H I J Z Z Z

Inserción

La inserción tiene lugar frente al elemento apuntado por el iterador.

insertar (posición const_iterator, const t & x)

El siguiente código muestra cómo se usa esta función:

vectorvtr 'f', 'g', 'h', 'i', 'j';
vector :: iterador p = vtr.comenzar();
p ++, p ++;
char id = 'z';
VTR.insertar (p, id);
para (int i = 0; icout<
cout<La salida es:

F G Z H I J

'Z' se ha insertado frente a H. La función de miembro begin () devuelve un iterador que apunta al primer elemento del vector. El iterador puede ser incrementado a la posición deseada. Tenga en cuenta que el segundo argumento esperado para insertar () aquí es un identificador.

Inserto iterador (posición const_iterator, t && x)

El siguiente código muestra cómo se usa esta función:

vectorvtr 'f', 'g', 'h', 'i', 'j';
vector :: iterador p = vtr.comenzar();
p ++, p ++;
VTR.insertar (p, 'z');
para (int i = 0; icout<
cout<La salida es:

F G Z H I J

'Z' se ha insertado frente a H. La función de miembro begin () devuelve un iterador que apunta al primer elemento del vector. Tenga en cuenta que el segundo argumento esperado para insertar () aquí es un literal.

Inserto iterador (posición const_iterator, size_type n, const t & x)

El mismo valor se puede insertar más de una vez. El siguiente código ilustra esto:

vectorvtr 'f', 'g', 'h', 'i', 'j';
vector :: iterador p = vtr.comenzar();
p ++, p ++;
char id = 'z';
VTR.insertar (p, 3, id);
para (int i = 0; icout<
cout<La salida es:

F G Z Z Z H I J

Iterator Insert (posición const_iterator, inputiterator primero, inputiterator Último)

Se puede insertar un rango de otro vector. El siguiente código ilustra esto:

vector othervtr = 'k', 'l', 'm', 'n', 'o';
vector :: iterator i = othervtr.comenzar();
i = i + 1;
vector :: iterator j = othervtr.fin();
j = j - 2;
vectorvtr 'f', 'g', 'h', 'i', 'j';
vector :: iterador p = vtr.comenzar();
p ++, p ++;
VTR.insertar (p, i, j);
para (int i = 0; icout<
cout<La salida es:

F g l m h i j

Para el otro vector, el rango se obtiene de la siguiente manera: la función de miembro begin () devuelve un iterador que apunta a su primer elemento. Este iterador, me incrementé para señalar el siguiente elemento. La función de miembro final () devuelve un iterador que apunta justo después del último elemento. Este iterador, J se disminuyó dos veces restando 2 de él, y luego señaló el elemento, 'n'.

En este punto, el rango imaginado es:

'L', 'm', 'n'

Sin embargo, con C ++, el último elemento en un rango no estará involucrado (insertado). Entonces, solo se inserta "'L', 'M'".

Inserto iterador (posición const_iterator, inicializador_list Illinois)

Se puede insertar una lista literal de vectores. El siguiente código ilustra esto:

vectorvtr 'f', 'g', 'h', 'i', 'j';
vector :: iterador p = vtr.comenzar();
p ++, p ++;
VTR.insert (p, 'k', 'l', 'm', 'n', 'o');
para (int i = 0; icout<
cout<La salida es:

F g k l m n o h i j

Emplárgico

El uso de emplace () es similar al uso de inserto (), y muchos programadores prefieren que insertar ().

Emplace dentro

Para el siguiente código, 'Z' está emplazado dentro de los valores, 'f', 'g', 'h', 'i', 'j':

vectorvtr 'f', 'g', 'h', 'i', 'j';
vector :: iterador p = vtr.comenzar();
p ++, p ++;
VTR.Emplace (P, 'Z');
para (int i = 0; icout<
cout<La salida es:

Emplace al frente

Para el siguiente código, 'Z' se emplaza frente a los valores, 'f', 'g', 'h', 'i', 'j':

vectorvtr 'f', 'g', 'h', 'i', 'j';
vector :: iterador p = vtr.comenzar();
VTR.Emplace (P, 'Z');
para (int i = 0; icout<
cout<El iterador devuelto por Begin () no fue incrementado; Y entonces la salida es:

Z F G H I J

Hacer retroceder

La función miembro push_back () se puede usar para agregar un elemento. El siguiente código ilustra esto:

vectorvtr 'f', 'g', 'h', 'i', 'j';
VTR.push_back ('z');
para (int i = 0; icout<
cout<La salida es:

F g h i j z

También se puede agregar un elemento utilizando la función miembro emplace_back (). El siguiente código ilustra esto:

vectorvtr 'f', 'g', 'h', 'i', 'j';
VTR.emplace_back ('z');
para (int i = 0; icout<
cout<La salida es:

F g h i j z

Conocer la longitud de un vector

El tamaño de un vector significa el número de elementos en el vector. Esto se puede obtener utilizando la función de miembro size (). El siguiente programa ilustra esto:

#incluir
#incluir
usando el espacio de nombres STD;
int main ()

vectorvtr = 'f', 'g', 'h', 'i', 'j', 'k';
int sz = vtr.tamaño();
cout<regresar 0;

La salida es 6.

Capacidad de un vector

La capacidad de un vector no debe confundirse con el tamaño del vector. Cuando se está manipulando y aumentando un vector, se están cambiando las ubicaciones de sus elementos en la memoria de la computadora (reasignado). La capacidad de un vector es el número total de elementos que el vector puede tener sin requerir la reasignación. Defiende con el tamaño inicial del vector. El siguiente programa ilustra esto para un vector vacío y para un vector de 5 elementos:

#incluir
#incluir
usando el espacio de nombres STD;
int main ()

Vector VTR1;
vector vtr2 'f', 'g', 'h', 'i', 'j';
int cap1 = vtr1.capacidad();
int cap2 = vtr2.capacidad();
cout<< cap1 <cout<< cap2 <regresar 0;

La salida es:

0
5

Reservar espacio para vector

Reserva vacía (size_type n)

El espacio vectorial se puede reservar con esta función. El siguiente programa reserva un espacio de 5 elementos:

#incluir
#incluir
usando el espacio de nombres STD;
int main ()

vectorvtr = 'f', 'g', 'h';
VTR.reserva (5);
int Cap = VTR.capacidad();
cout<< "New Capacity: " << cap <VTR.push_back ('i');
VTR.push_back ('j');
VTR.push_back ('k');
para (int i = 0; icout<
cout<regresar 0;

La salida es:

Nueva capacidad: 5
F g h i j k

Los espacios reservados incluyen los de los elementos iniciales. El hecho de que se reserven 5 espacios no significa que un elemento no se pueda agregar más allá de los 5 elementos.

Conclusión

"Expandir un vector" no es una frase clásica en C++. Sin embargo, si "expandir un vector" significa, aumentar la longitud de un vector, entonces, sí, se puede ampliar un vector. En C ++, la longitud de un vector o cualquier contenedor C ++ se llama tamaño. El vector se puede ampliar con las siguientes funciones del miembro: resize (), insert (), emplace () y push_back (). Otras funciones de miembros relacionados son: size (), capacidad () y reserva (). En muchos programas de C ++, un vector aumentaría y disminuiría varias veces. Se puede disminuir un vector, utilizando la función de miembro de borrado; ver más tarde. Si un vector consta de literales de cadena, entonces el vector puede ser reemplazado por una cadena larga compuesta por literales de cadena.