30 ejemplos de vectores de C++

30 Ejemplos De Vectores De C



En C++, Vector es una estructura de datos unidimensional que aumenta dinámicamente según los requisitos. La organización de datos (inserción/modificación/eliminación) se puede realizar de manera eficiente en esta estructura de datos. Entre sus aplicaciones se incluyen las siguientes:

  1. Representar los vectores matemáticos en aplicaciones científicas y de ingeniería.
  2. Se pueden implementar colas, pilas utilizando esta estructura de datos, etc.

La mayoría de las operaciones y funciones CRUD comunes relacionadas con esta estructura de datos se analizan en detalle en cada escenario con sintaxis y fragmentos de código.







Tema de contenidos:

  1. Insertar un elemento en un vector
  2. Insertar múltiples elementos en un vector
  3. Acceder a los elementos desde un vector
  4. Actualizar el elemento en un vector
  5. Eliminar un elemento específico de un vector
  6. Eliminar todos los elementos de un vector
  7. Unión de vectores
  8. Intersección de vectores
  9. Compruebe si el vector está vacío o no
  10. Atravesar un vector usando Const_Iterator
  11. Atravesar un vector usando Reverse_Iterator
  12. Empuje los elementos dentro del vector
  13. Explota los elementos del vector
  14. Intercambiar los vectores
  15. Obtener el primer elemento del vector
  16. Obtener el último elemento del vector
  17. Asignar nuevos valores a un vector
  18. Extender el vector usando Emplace()
  19. Extender el vector usando Emplace_Back()
  20. Elemento máximo de un vector
  21. Elemento mínimo de un vector
  22. Suma de elementos en un vector
  23. Multiplicación por elementos de dos vectores
  24. Producto escalar de dos vectores
  25. Convertir un conjunto en un vector
  26. Eliminar los elementos duplicados
  27. Convertir un vector en un conjunto
  28. Eliminar las cadenas vacías
  29. Escribir un vector en un archivo de texto
  30. Crear un vector a partir de un archivo de texto

Insertar un elemento en un vector

El std::vector::insertar() La función en C++ STL se utiliza para insertar los elementos en la posición especificada.



Sintaxis:

vector. insertar ( posición, elemento ) ;

Utilicemos esta función y pasemos la primera posición como un parámetro que especifica la posición donde se debe insertar el elemento y proporcionemos el elemento como segundo parámetro.



La función comenzar() se puede utilizar aquí para devolver un iterador que apunte al primer elemento del vector de entrada. Al agregar la posición a esta función, el elemento se inserta en esa posición.





Creemos el vector 'student_names' de tipo cadena e insertemos dos cadenas en la primera y segunda posición, una tras otra, usando la función insert().

#incluir

usando espacio de nombres enfermedad de transmisión sexual ;

principal ( )

{

    // Inicializando el vector - nombres_estudiantes

vector < cadena > nombres_estudiantes ;

    corte << 'Vector existente: \norte ' ;

    para ( auto i : nombres_estudiantes ) corte << i << fin ;

    // Insertamos 'Sravan Kumar' en la primera posición

nombres_estudiantes. insertar ( nombres_estudiantes. comenzar ( ) + 0 , 'Shravan Kumar' ) ;

    // Inserta 'Sravan Kumar' en la segunda posición

nombres_estudiantes. insertar ( nombres_estudiantes. comenzar ( ) + 1 , 'Lalitha' ) ;

    corte << 'Vector final: \norte ' ;

    para ( auto j : nombres_estudiantes ) corte << j << fin ;

}

Producción:

Anteriormente, el vector 'student_names' estaba vacío. Después de la inserción, el vector contiene dos elementos.



Insertar múltiples elementos en un vector

Usamos la misma función que es std::vector::insert() en este escenario. Pero necesitamos pasar los parámetros adicionales/diferentes a la misma función para insertar múltiples elementos en un vector.

Escenario 1: Insertar un solo elemento varias veces

En este escenario, agregamos el mismo elemento varias veces.

Sintaxis:

vector. insertar ( posición, tamaño, elemento ) ;

Para hacer esto, necesitamos pasar el tamaño como segundo parámetro a la función insert(). El total de parámetros que se pasan a esta función es tres.

Aquí:

  1. El parámetro de posición especifica la posición del elemento que se insertará. Si el tamaño es mayor que 1, el índice de la posición inicial será la posición.
  2. El parámetro de tamaño especifica el número de veces que se insertará un elemento.
  3. El parámetro del elemento toma el elemento que se insertará en un vector.

Considere el vector 'student_names' con dos cadenas. Inserta las cuerdas “Lavanya” cinco veces en la segunda posición.

#incluir

usando espacio de nombres enfermedad de transmisión sexual ;

principal ( )

{

    // Inicializando el vector - nombres_estudiantes

vector < cadena > nombres_estudiantes { 'Shravan Kumar' , 'Lalitha' } ;

    corte << 'Vector existente: \norte ' ;

    para ( auto i : nombres_estudiantes ) corte << i << fin ;

    // Inserta 'Lavanya' en la segunda posición 5 veces

nombres_estudiantes. insertar ( nombres_estudiantes. comenzar ( ) + 1 , 5 , 'Lavanya' ) ;

    corte << ' \norte Vector final: \norte ' ;

    para ( auto j : nombres_estudiantes ) corte << j << fin ;

}

Producción:

En el vector existente, “Sravan Kumar” está en la primera posición y “Lalitha” está en la segunda posición. Después de insertar “Lavanya” cinco veces (de la segunda posición a la sexta), “Lalitha” pasó a la séptima posición (última).

Escenario 2: Insertar varios elementos

En este escenario, sumamos los diferentes elementos a la vez desde otro vector. También usamos la misma función aquí pero la sintaxis y los parámetros cambiarán.

Sintaxis:

vector. insertar ( posición, primer_iterador, segundo_iterador ) ;

Para hacer esto, necesitamos pasar el tamaño como segundo parámetro a la función insert(). El total de parámetros que se pasan a esta función es tres.

Aquí:

  1. El parámetro de posición especifica la posición del elemento que se insertará.
  2. El “first_iterator” especifica la posición inicial desde la cual se insertarán los elementos (básicamente, usando la función comenzar(), se devuelve un iterador que apunta al primer elemento que está presente en el contenedor).
  3. El “segundo_iterador” especifica la posición final hasta la cual se insertarán los elementos (básicamente, usando la función end(), se devuelve un iterador que apunta al último punto que está presente en el contenedor).

Cree dos vectores, “marcas1” y “marcas2”, de tipo entero. Inserte todos los elementos que están presentes en el vector 'marks2' en la primera posición del vector 'marks1'.

#incluir

usando espacio de nombres enfermedad de transmisión sexual ;

principal ( )

{

    // Inicializando el vector - marks1

vector < En t > marcas1 { 100 , 89 , 90 , 78 , 98 } ;

    corte << 'Primer vector: \norte ' ;

    para ( auto i : marcas1 ) corte << i << fin ;

    // Inicializando el vector - marks2

vector < En t > marcas2 { 56 , 45 , 65 } ;

    corte << 'Segundo vector: \norte ' ;

    para ( auto j : marcas2 ) corte << j << fin ;

marcas1. insertar ( comenzar ( marcas1 ) , comenzar ( marcas2 ) , fin ( marcas2 ) ) ;

 

  // vector final

    corte << 'Vector primero-final: \norte ' ;

    para ( auto X : marcas1 )

    corte << X << ' ' ;

}

Producción:

El primer vector (marcas1) contiene cinco elementos y el segundo vector (marcas2) contiene tres elementos. Pasamos los parámetros de inicio (marcas1), inicio (marcas2), fin (marcas2) a la función 'insertar' de modo que todos los elementos que están presentes en el segundo vector se iteren y se inserten en el primer vector al principio. Entonces, el primer vector contiene ocho elementos.

Acceder a los elementos desde un vector

1. Usando el operador []

En algunos escenarios, es posible que deba devolver solo los elementos específicos del vector. No es necesario devolver todos los elementos. Entonces, para devolver solo los elementos específicos basados ​​en el índice, se utilizan el operador de índice y las funciones at().

Sintaxis:

vector [ posición_indice ]

En C++, la indexación comienza desde 0 para cualquier estructura de datos. Si el elemento no existe, devuelve vacío (no se produce ningún error o se genera una advertencia).

Considere el vector 'productos' con cinco elementos. Accede a todos los elementos uno por uno usando la posición del índice.

#incluir

usando espacio de nombres enfermedad de transmisión sexual ;

principal ( )

{

    // Crear vector - productos con 5 cadenas

vector < cadena > productos { 'jabón' , 'champú' , 'aceite' , 'frutas' , 'verduras' } ;

    //Accediendo a elementos de los productos

  corte << 'Primer elemento:' << productos [ 0 ] << fin ;

  corte << 'Segundo elemento:' << productos [ 1 ] << fin ;

  corte << 'Tercer elemento:' << productos [ 2 ] << fin ;

  corte << 'Cuarto Elemento:' << productos [ 3 ] << fin ;

  corte << 'Quinto Elemento:' << productos [ 4 ] << fin ;

 

  // Intenta acceder al noveno elemento

  corte << 'Noveno elemento:' << productos [ 8 ] << fin ;

}

Producción:

No hay ningún elemento presente en el índice 8. Por lo tanto, se devuelve vacío.

2. Usando la función At()

At() es una función miembro que es similar al caso de uso anterior pero devuelve la excepción 'std::out_of_range' cuando se le proporciona el índice fuera de rango.

Sintaxis:

vector. en ( posición_indice )

Necesitamos pasar la posición del índice a esta función.

Considere el vector 'productos' con cinco elementos. Acceda a todos los elementos uno por uno usando la posición del índice e intente acceder al elemento que está presente en la novena posición.

#incluir

usando espacio de nombres enfermedad de transmisión sexual ;

principal ( )

{

    // Crear vector - productos con 5 cadenas

vector < cadena > productos { 'jabón' , 'champú' , 'aceite' , 'frutas' , 'verduras' } ;

    //Accediendo a elementos de los productos

  corte << 'Primer elemento:' << productos. en ( 0 ) << fin ;

  corte << 'Segundo elemento:' << productos. en ( 1 ) << fin ;

  corte << 'Tercer elemento:' << productos. en ( 2 ) << fin ;

  corte << 'Cuarto Elemento:' << productos. en ( 3 ) << fin ;

  corte << 'Quinto Elemento:' << productos. en ( 4 ) << fin ;

 

  //Accediendo a los elementos que no están en el vector

  corte << 'Noveno elemento:' << productos. en ( 8 ) << fin ;

}

Producción:

Se produce un error al acceder al noveno elemento:

terminar llamado después de lanzar una instancia de 'std::fuera_de_rango'

qué ( ) : vector :: _M_range_check : __norte ( cual es 8 ) >= este - > tamaño ( ) ( cual es 5 )

Actualizar un elemento en un vector

1. Usando el operador []

Usando la posición del índice, podemos actualizar el elemento en el vector. El operador [] toma la posición de índice del elemento que debe actualizarse. El nuevo elemento será asignado a este operador.

Sintaxis:

Vector [ posición_indice ] = Elemento

Considere el vector 'student_marks' con cinco valores. Actualice los elementos presentes en los índices 1 y 3.

#incluir

#incluir

usando espacio de nombres enfermedad de transmisión sexual ;

principal ( )

{

    // Crear vector - Student_marks

vector < En t > notas_estudiantes { 98 , 78 , 90 , 67 , 89 } ;

    corte << 'Marcas existentes: ' << fin ;

        para ( En t itr : notas_estudiantes )

        corte << itr << fin ;

        // Actualizar elemento en índice-3 con 100

notas_estudiantes [ 3 ] = 100 ;

            // Actualizar elemento en índice-1 con 60

notas_estudiantes [ 1 ] = 60 ;

        corte << 'Calificaciones finales: ' << fin ;

        para ( En t itr : notas_estudiantes )

        corte << itr << fin ;

}

Producción:

Podemos ver que el vector final contiene los elementos de actualización en los índices 1 y 3.

2. Usando la función At()

Similar al operador de índice, at() es básicamente una función miembro que actualiza el valor según el índice en un iterador. Si el índice especificado dentro de esta función no existe, se genera la excepción 'std::out_of_range'.

vector. en ( posición_indice ) = Elemento

Considere el vector 'productos' con cinco elementos. Actualiza todos los elementos presentes en el vector con otros elementos.

#incluir

usando espacio de nombres enfermedad de transmisión sexual ;

principal ( )

{

    // Crear vector - productos con 5 cadenas

vector < cadena > productos { 'jabón' , 'champú' , 'aceite' , 'frutas' , 'verduras' } ;

    corte << 'Productos existentes: ' << fin ;

        para ( cuerda itr : productos )

        corte << itr << fin ;

    //Actualizando todas las cadenas

productos. en ( 0 ) = 'Pastel' ;

productos. en ( 1 ) = 'Chocolate' ;

productos. en ( 2 ) = 'Frutas' ;

productos. en ( 3 ) = 'Cebollas' ;

productos. en ( 4 ) = 'Bebidas sin alcohol' ;

 

  corte << ' \norte Productos finales: ' << fin ;

        para ( cuerda itr : productos )

        corte << itr << fin ;

}

Producción:

Eliminar un elemento específico de un vector

En C++, el std::vector::erase() La función se utiliza para eliminar un elemento/rango de elementos específico de un vector. Los elementos se eliminan según las posiciones del iterador.

Sintaxis:

vector. borrar ( posición del iterador )

Veamos la sintaxis para eliminar el elemento específico de un vector. Podemos utilizar las funciones comenzar() o finalizar() para obtener la posición del elemento que está presente en el vector que se va a eliminar.

Considere el vector 'productos' con cinco elementos.

  1. Elimine el tercer elemento especificando el iterador comenzar(). Begin() apunta al primer elemento del vector. Si a esta función le sumamos dos, apunta al tercer elemento.
  2. Elimine el último elemento especificando el iterador end(). End() apunta al último elemento del vector.
#incluir

usando espacio de nombres enfermedad de transmisión sexual ;

principal ( )

{

    // Crear vector - productos con 5 cadenas

vector < cadena > productos { 'jabón' , 'champú' , 'aceite' , 'frutas' , 'verduras' } ;

    corte << 'Productos existentes: ' << fin ;

        para ( cuerda itr : productos )

        corte << itr << fin ;

 

      // Elimina el tercer elemento

productos. borrar ( productos. comenzar ( ) + 2 ) ;

      corte << ' \norte Después de eliminar el tercer elemento: \norte ' ;

      para ( cuerda itr : productos )

        corte << itr << fin ;

        // Elimina el último elemento

productos. borrar ( productos. fin ( ) ) ;

    corte << ' \norte Después de eliminar el último elemento: \norte ' ;

    para ( cuerda itr : productos )

        corte << itr << fin ;

}

Producción:

Ahora bien, solo existen tres elementos (“jabón”, “champú”, “frutas”) que existen en el vector “productos”.

Eliminar todos los elementos de un vector

Escenario 1: eliminar una variedad de elementos de un vector

Usemos la función std::vector::erase() para eliminar varios elementos en un rango.

Sintaxis:

vector. borrar ( iterador primero, iterador último )

Los dos iteradores (begin() apunta al primer elemento y end() apunta a las funciones del último elemento) se utilizan para especificar el rango.

Considere el vector 'productos' con cinco elementos y elimine todos los elementos de la segunda posición. Para lograr esto, el primer iterador es inicio (productos) +1 que apunta al segundo elemento y el segundo iterador es final (productos).

#incluir

usando espacio de nombres enfermedad de transmisión sexual ;

principal ( )

{

    // Crear vector - productos con 5 cadenas

vector < cadena > productos { 'jabón' , 'champú' , 'aceite' , 'frutas' , 'verduras' } ;

    corte << 'Productos existentes: ' << fin ;

        para ( cuerda itr : productos )

        corte << itr << fin ;

 

      // Elimina todos los elementos de la segunda posición.

productos. borrar ( comenzar ( productos ) + 1 ,fin ( productos ) ) ;

      corte << ' \norte Productos finales: \norte ' ;

      para ( cuerda itr : productos )

        corte << itr << fin ;

}

Producción:

Ahora, sólo hay un elemento (“jabón”) que está presente en el vector “productos”.

Escenario 2: eliminar todos los elementos del vector

usemos el std::vector::claro() función para eliminar todos los elementos del vector.

Sintaxis:

vector. claro ( )

No se pasan parámetros a esta función.

Considere el mismo vector que se utilizó en el primer escenario y elimine todos los elementos usando la función clear().

#incluir

usando espacio de nombres enfermedad de transmisión sexual ;

principal ( )

{

    // Crear vector - productos con 5 cadenas

vector < cadena > productos { 'jabón' , 'champú' , 'aceite' , 'frutas' , 'verduras' } ;

    corte << 'Productos existentes: ' << fin ;

        para ( cuerda itr : productos )

        corte << itr << fin ;

 

    // Elimina todos los elementos de los productos.

productos. claro ( ) ;

    corte << ' \norte Productos finales: \norte ' ;

    para ( cuerda itr : productos )

        corte << itr << fin ;

}

Producción:

Podemos ver que no hay elementos en el vector “productos”.

Unión de vectores

Es posible realizar la operación UNION en vectores usando la función std::set_union(). Union devuelve los elementos únicos de los vectores ignorando los elementos duplicados. Necesitamos pasar ambos iteradores a esta función. Junto con esto, se debe pasar un iterador de salida que almacena el resultado devuelto por ambos iteradores.

Sintaxis:

conjunto_union ( InputIterator1 primero1, InputIterator1 último1, InputIterator2 primero2, InputIterator2 último2, OutputIterator res ) ;

Aquí:

  1. El 'primer1' apunta al primer elemento del primer iterador (vector).
  2. El 'último1' apunta al último elemento del primer iterador (vector).
  3. El 'primero2' apunta al primer elemento del segundo iterador (vector).
  4. El 'último2' apunta al último elemento del segundo iterador (vector).

Cree dos vectores, “sujetos1” y “sujetos2”, de tipo entero.

  1. Ordene los dos vectores usando la función sort() pasando los iteradores.
  2. Cree un vector de salida (iterador).
  3. Encuentre la unión de estos dos vectores usando la función std::set_union(). Utilice begin() como primer iterador y end() como último iterador.
  4. Itere el vector de salida para mostrar los elementos que devuelve la función.
#incluir

#incluir

#incluir

usando espacio de nombres enfermedad de transmisión sexual ;

principal ( )

{

    // Crear vector - marcas1

vector < En t > marcas1 = { 100 , 90 , 80 , 70 , 60 } ;

 

  // Crear vector - marcas2

vector < En t > marcas2 = { 80 , 90 , 60 , 70 , 100 } ;

    // Ordena ambos vectores

clasificar ( marcas1. comenzar ( ) , marcas1. fin ( ) ) ;

clasificar ( marcas2. comenzar ( ) , marcas2. fin ( ) ) ;

vector < En t > vector de salida ( marcas1. tamaño ( ) + marcas2. tamaño ( ) ) ;

vector < En t > :: iterador es ;

i = conjunto_union ( marcas1. comenzar ( ) , marcas1. fin ( ) ,

marcas2. comenzar ( ) ,marcas2. fin ( ) ,

vector de salida. comenzar ( ) ) ;

    corte << ' \norte marcas1 U marcas2: \norte ' ;

    para ( s = vector de salida. comenzar ( ) ; s ! = i ; ++ s )

        corte << * s << ' ' << ' \norte ' ;

}

Producción:

Sólo hay cinco elementos únicos en ambos vectores (sujetos1 y sujetos2).

Intersección de vectores

Es posible encontrar la intersección de dos vectores utilizando la función std::set_intersection(). La intersección devuelve los elementos que están presentes en ambos vectores.

Sintaxis:

conjunto_intersección ( InputIterator1 primero1, InputIterator1 último1, InputIterator2 primero2, InputIterator2 último2, OutputIterator res ) ;

Los parámetros que se pasan a la función set_union() también se pueden pasar a esta función set_intersection().

Cree dos vectores, “sujetos1” y “sujetos2”, de tipo entero.

  1. Ordene los dos vectores usando la función sort() pasando los iteradores.
  2. Cree un vector de salida (iterador).
  3. Encuentre la intersección de estos dos vectores usando la función std::set_intersection(). Utilice begin() como primer iterador y end() como último iterador.
  4. Itere el vector de salida para mostrar los elementos que devuelve la función.
#incluir

#incluir

#incluir

usando espacio de nombres enfermedad de transmisión sexual ;

principal ( )

{

    // Crear vector - marcas1

vector < En t > marcas1 = { 100 , 10 , 80 , 40 , 60 } ;

 

  // Crear vector - marcas2

vector < En t > marcas2 = { 50 , 90 , 60 , 10 , 100 } ;

    // Ordena ambos vectores

clasificar ( marcas1. comenzar ( ) , marcas1. fin ( ) ) ;

clasificar ( marcas2. comenzar ( ) , marcas2. fin ( ) ) ;

vector < En t > vector de salida ( marcas1. tamaño ( ) + marcas2. tamaño ( ) ) ;

vector < En t > :: iterador es ;

i = conjunto_intersección ( marcas1. comenzar ( ) , marcas1. fin ( ) ,

marcas2. comenzar ( ) ,marcas2. fin ( ) ,

vector de salida. comenzar ( ) ) ;

    corte << ' \norte marcas1 ∩ marcas2: \norte ' ;

    para ( s = vector de salida. comenzar ( ) ; s ! = i ; ++ s )

        corte << * s << ' ' << ' \norte ' ;

}

Producción:

Sólo hay tres elementos presentes en ambos vectores (sujetos1 y sujetos2).

Compruebe si el vector está vacío o no

Antes de trabajar con vectores, es importante comprobar si el vector está vacío o no. También es una buena práctica en proyectos de software verificar si el vector está vacío o no antes de realizar operaciones como operaciones CRUD, etc.

1. Usando Std::vector::empty()

Esta función devuelve 1 si el vector está vacío (no contiene ningún elemento). De lo contrario, se devuelve 0. No se pasa ningún parámetro a esta función.

2. Usando el Estándar::vector::tamaño()

La función std::vector::size() devuelve el número entero que representa el número total de elementos que están presentes en el vector.

Cree dos vectores: “college1” y “college2”. “College1” contiene cinco elementos y “college2” está vacío. Aplique ambas funciones en ambos vectores y verifique la salida.

#incluir

#incluir

#incluir

usando espacio de nombres enfermedad de transmisión sexual ;

principal ( )

{

    // Crear vector - college1

vector < cadena > universidad1 = { 'universidad-A' , 'universidad-B' , 'universidad-C' , 'universidad-D' , 'universidad-E' } ;

    // Crear vector - college2

vector < cadena > universidad2 ;

    // vacío()

    corte << universidad1. vacío ( ) << fin ;

    corte << universidad2. vacío ( ) << fin ;

        // tamaño()

    corte << universidad1. tamaño ( ) << fin ;

    corte << universidad2. tamaño ( ) << fin ;

}

Producción:

La función vacía() devuelve 0 para 'college1' y 1 para 'college2'. La función size() devuelve cinco para “college1” y 0 para “college2”.

Atravesar un vector usando Const_Iterator

Cuando se trabaja en contenedores de C++ como conjuntos, vectores, etc., es posible iterar sobre todos los elementos que están presentes en el contenedor sin modificarlos. El const_iterador es uno de los iteradores que logran este escenario. cbegin() (apunta al primer elemento del vector) y cend() (apunta al último elemento del vector) son las dos funciones proporcionadas por cada contenedor que se utiliza para devolver el iterador constante al principio y al final de El contenedor. Mientras iteramos el vector, podemos utilizar estas dos funciones.

  1. Creemos un vector llamado 'departamentos' con cinco cadenas.
  2. Declare un const_iterator – ctr de tipo .
  3. Itere sobre los departamentos utilizando el iterador anterior utilizando el bucle 'for' y muéstrelo.
#incluir

#incluir

usando espacio de nombres enfermedad de transmisión sexual ;

principal ( )

{

    // Crear vector - departamentos

vector < cadena > departamentos = { 'Ventas' , 'Servicio' ,

                  'HORA' , 'ÉL' , 'Otros' } ;

 

vector < cadena > :: const_iterador centro ;

  // Iterar sobre los departamentos usando const_iterator - ctr.

    para ( centro = departamentos. comenzar ( ) ; centro ! = departamentos. algunos ( ) ; centro ++ ) {

        corte << * centro << fin ;

    }

}

Producción:

Atravesar un vector usando Reverse_Iterator

El iterador_inverso También es un iterador similar a const_iterator pero devuelve los elementos al revés. rbegin() (apunta al último elemento del vector) y rend() (apunta al primer elemento del vector) son las dos funciones proporcionadas por cada contenedor que se utiliza para devolver el iterador constante al final y al comienzo de El contenedor.

  1. Creemos un vector llamado 'departamentos' con cinco cadenas.
  2. Declare un iterador inverso – rtr de tipo .
  3. Itere sobre los departamentos utilizando el iterador anterior utilizando el bucle 'for' y muéstrelo.
#incluir

#incluir

usando espacio de nombres enfermedad de transmisión sexual ;

principal ( )

{

    // Crear vector - departamentos

vector < cadena > departamentos = { 'Ventas' , 'Servicio' ,

                  'HORA' , 'ÉL' , 'Otros' } ;

 

vector < cadena > :: iterador_inverso rtr ;

  // Iterar sobre los departamentos usando reverse_iterator - rtr.

    para ( rtr = departamentos. comenzar ( ) ; rtr ! = departamentos. marcas ( ) ; rtr ++ ) {

        corte << * rtr << fin ;

    }

}

Producción:

Empuje los elementos dentro del vector

Empujar o agregar elementos a un vector es una inserción unidireccional que se puede realizar usando el vector::push_back() función.

Sintaxis:

vector. hacer retroceder ( elemento )

Se necesita un elemento para insertarlo en el vector como parámetro.

Creemos un vector vacío llamado 'departamentos' con cinco cadenas y empujemos dos cadenas una tras otra usando la función push_back().

#incluir

#incluir

usando espacio de nombres enfermedad de transmisión sexual ;

principal ( )

{

    // Inicializar vector - departamentos

vector < cadena > departamentos ;

    corte << 'Departamentos reales:' << fin ;

    para ( auto itr = departamentos. comenzar ( ) ; itr ! = departamentos. fin ( ) ; ++ itr )

        corte << * itr << fin ;

    // Empuja 'Ventas'

departamentos. hacer retroceder ( 'Ventas' ) ;

    // Empujalo'

departamentos. hacer retroceder ( 'ÉL' ) ;

  corte << ' \norte Departamentos Finales:' << fin ;

    para ( auto itr = departamentos. comenzar ( ) ; itr ! = departamentos. fin ( ) ; ++ itr )

        corte << * itr << fin ;

}

Producción:

Primero, presionamos las 'Ventas'. Después de eso, 'IT' se introduce en el vector. Ahora, el vector 'departamentos' contiene dos elementos.

Explota los elementos del vector

Si desea eliminar el último elemento que está presente en el vector, utilizando el vector::pop_back() La función es el mejor enfoque. Elimina el último elemento que está presente en el vector.

Sintaxis:

vector. pop_back ( )

No se necesita ningún parámetro para esta función. Muestra el comportamiento indefinido si intentamos eliminar el último elemento de un vector vacío.

Creemos un vector vacío llamado 'departamentos' con cinco cadenas y eliminemos el último elemento usando la función anterior. Muestre el vector en ambos casos.

#incluir

#incluir

usando espacio de nombres enfermedad de transmisión sexual ;

principal ( )

{

    // Inicializar vector - departamentos

vector < cadena > departamentos = { 'Ventas' , 'ÉL' , 'Servicio' , 'Marketing' , 'HORA' } ;

    corte << 'Departamentos reales:' << fin ;

    para ( auto itr = departamentos. comenzar ( ) ; itr ! = departamentos. fin ( ) ; ++ itr )

        corte << * itr << fin ;

 

    // Elimina el último elemento

departamentos. pop_back ( ) ;

    corte << ' \norte Departamentos Finales:' << fin ;

    para ( auto itr = departamentos. comenzar ( ) ; itr ! = departamentos. fin ( ) ; ++ itr )

    corte << * itr << fin ;

}

Producción:

'RRHH' es el último elemento que está presente en el vector 'departamentos'. Por lo tanto, se elimina del vector y el vector final contiene 'Ventas', 'TI', 'Servicio' y 'Marketing'.

Intercambiar los vectores

El vector::intercambiar() La función en C++ STL se utiliza para intercambiar todos los elementos que están presentes en dos vectores.

Sintaxis:

primer_vector. intercambio ( segundo_vector )

No considera el tamaño de los vectores pero los vectores deben ser del mismo tipo (se arroja error si los tipos de vectores son diferentes).

Creemos dos vectores – “frutas” y “verduras” – de tipo cadena con diferentes tamaños. Intercambie cada uno de ellos y muestre los vectores en ambos casos.

#incluir

#incluir

usando espacio de nombres enfermedad de transmisión sexual ;

principal ( )

{

    // Inicializar vector - frutas

vector < cadena > frutas = { 'Manzana' , 'Mango' } ;

    corte << 'Frutas reales:' << fin ;

    para ( auto itr = frutas. comenzar ( ) ; itr ! = frutas. fin ( ) ; ++ itr )

        corte << * itr << fin ;

 

  // Inicializar vector - vegetales

vector < cadena > verduras = { 'Papa' , 'Tomate' , 'Brenja' } ;

    corte << ' \norte Verduras reales:' << fin ;

    para ( auto itr = verduras. comenzar ( ) ; itr ! = verduras. fin ( ) ; ++ itr )

        corte << * itr << fin ;

 

  // Intercambia los elementos en ambos vectores.

frutas. intercambio ( verduras ) ;

corte << ' \norte Frutas después del intercambio:' << fin ;

    para ( auto itr = frutas. comenzar ( ) ; itr ! = frutas. fin ( ) ; ++ itr )

        corte << * itr << fin ;

corte << ' \norte Verduras después del intercambio:' << fin ;

    para ( auto itr = verduras. comenzar ( ) ; itr ! = verduras. fin ( ) ; ++ itr )

        corte << * itr << fin ;

}

Producción:

Anteriormente, el vector “frutas” contiene dos elementos y el vector “verduras” contiene tres elementos. Después del intercambio, el vector 'frutas' contiene tres elementos y el vector 'verduras' contiene dos elementos.

Obtener el primer elemento del vector

En algunos casos, el requisito es devolver sólo el primer elemento del vector. La función vector::front() en C++ STL recupera solo el primer elemento del vector.

Sintaxis:

vector. frente ( )

Esta función no tomará ningún parámetro. Si el vector está vacío, se genera un error.

Creemos dos vectores – “frutas” y “verduras” – de tipo cadena e intentemos recuperar el primer elemento por separado de los dos vectores.

#incluir

#incluir

usando espacio de nombres enfermedad de transmisión sexual ;

principal ( )

{

    // Crear vector - frutas con 2 elementos

vector < cadena > frutas = { 'Manzana' , 'Mango' } ;

    // Devuelve el primer elemento

  corte << frutas. frente ( ) << fin ;

 

  // Inicializar vector - vegetales

vector < cadena > verduras ;

    // Intenta devolver el primer elemento

  corte << verduras. frente ( ) ;

}

Producción:

'Apple' es el primer elemento que está presente en el vector 'frutas'. Entonces, se devuelve. Pero se produce un error cuando intentamos recuperar el primer elemento del vector 'verduras' ya que está vacío.

Obtener el último elemento del vector

La función vector::end() en C++ STL recupera solo el último elemento del vector.

Sintaxis:

vector. atrás ( )

Esta función no tomará ningún parámetro. Si el vector está vacío, se genera un error.

Creemos dos vectores – “frutas” y “verduras” – de tipo cadena e intentemos recuperar el último elemento por separado de los dos vectores.

#incluir

#incluir

usando espacio de nombres enfermedad de transmisión sexual ;

principal ( )

{

    // Crear vector - frutas con 2 elementos

vector < cadena > frutas = { 'Manzana' , 'Mango' } ;

    // Recupera el último elemento

  corte << frutas. atrás ( ) << fin ;

 

  // Inicializar vector - vegetales

vector < cadena > verduras ;

    // Intenta buscar el último elemento

  corte << verduras. atrás ( ) ;

}

Producción:

“Mango” es el último elemento presente en el vector “frutas”. Entonces, se devuelve. Pero se produce un error cuando intentamos recuperar el último elemento del vector 'verduras' ya que está vacío.

Asignar nuevos valores a un vector

En algunos escenarios, si desea actualizar todos los valores con el nuevo valor o crear un vector con los mismos valores, usar la función vector::assign() es el mejor enfoque. Usando esta función, podemos:

  1. Crea el vector con todos los elementos similares.
  2. Modificar el vector existente con el mismo elemento.

Sintaxis:

vector. asignar ( tamaño, valor )

Se requieren dos parámetros para esta función.

Aquí:

  1. El tamaño especifica el número de elementos que se asignarán.
  2. El valor especifica el elemento que se asignará.

Creemos un vector llamado 'marcas1' con cinco valores y actualicemos este vector con cuatro elementos de modo que todos los elementos en el vector actualizado sean iguales a 20.

#incluir

#incluir

#incluir

usando espacio de nombres enfermedad de transmisión sexual ;

principal ( )

{

    // Crear vector - marcas1

vector < En t > marcas1 = { 100 , 90 , 80 , 70 , 60 } ;

    corte << 'Vector real:' << fin ;

  para ( En t i = 0 ; i < marcas1. tamaño ( ) ; i ++ )

        corte << marcas1 [ i ] << fin ;

 

marcas1. asignar ( 4 , 20 ) ;

 

        corte << ' \norte Vector actualizado:' << fin ;

  para ( En t i = 0 ; i < marcas1. tamaño ( ) ; i ++ )

        corte << marcas1 [ i ] << fin ;

}

Producción:

Anteriormente, el vector contiene cinco elementos diferentes. Ahora solo contiene cuatro elementos y todos son iguales a 20.

Extender el vector usando Emplace()

Ya sabemos que los nuevos elementos se insertan dinámicamente en cualquier posición de un vector. Es posible utilizando la función vector::emplace(). Veamos rápidamente la sintaxis y los parámetros aceptados por esta función.

Sintaxis:

vector. ubicación ( posición const_iterator, elemento )

Se pasan dos parámetros obligatorios a esta función.

Aquí:

  1. El primer parámetro toma la posición para que podamos insertar el elemento en cualquier posición. Podemos obtener la posición usando la función iteradora start() o end().
  2. El segundo parámetro es el elemento que se insertará en el vector.

Consideremos el vector “químicos” con dos elementos.

  1. Inserte “Manganeso” en la primera posición – comenzar (productos químicos)
  2. Inserte “Cobre” en la última posición – final (químicos)
  3. Inserte 'Azufre' en la tercera posición – comenzar (productos químicos) +2
#incluir

#incluir

#incluir

usando espacio de nombres enfermedad de transmisión sexual ;

principal ( )

{

    // Crear vector - químicos

vector < cadena > quimicos = { 'Oxígeno' , 'CO' } ;

  corte << 'Productos químicos reales:' << fin ;

  para ( En t i = 0 ; i < productos químicos. tamaño ( ) ; i ++ )

  corte << quimicos [ i ] << fin ;

 

  // Insertar elemento en la primera posición

productos químicos. ubicación ( comenzar ( quimicos ) , 'Manganeso' ) ;

 

  // Insertar elemento en la última posición

productos químicos. ubicación ( fin ( quimicos ) , 'Cobre' ) ;

 

  // Insertar elemento en la tercera posición

productos químicos. ubicación ( comenzar ( quimicos ) + 2 , 'Azufre' ) ;

 

  corte << ' \norte Productos químicos finales:' << fin ;

  para ( En t i = 0 ; i < productos químicos. tamaño ( ) ; i ++ )

      corte << quimicos [ i ] << fin ;

}

Producción:

Ahora, el vector final contiene cinco elementos (que se muestran en la siguiente captura de pantalla).

Extender el vector usando Emplace_Back()

Se puede agregar un elemento (agregándolo al final del vector), lo cual se puede hacer usando el vector::emplace_back() función.

Sintaxis:

vector. emplace_back ( elemento )

Es obligatorio pasar el elemento que se agregará al vector como parámetro.

Agreguemos dos elementos uno tras otro usando la función emplace_back().

#incluir

#incluir

#incluir

usando espacio de nombres enfermedad de transmisión sexual ;

principal ( )

{

    // Crear vector - químicos

vector < cadena > quimicos = { 'Oxígeno' , 'CO' } ;

  corte << 'Productos químicos reales:' << fin ;

  para ( En t i = 0 ; i < productos químicos. tamaño ( ) ; i ++ )

      corte << quimicos [ i ] << fin ;

 

  // Insertamos Manganeso al final del vector.

productos químicos. emplace_back ( 'Manganeso' ) ;

 

  // Insertamos Manganeso al final del vector.

productos químicos. emplace_back ( 'Cobre' ) ;

 

 

    corte << ' \norte Productos químicos finales:' << fin ;

  para ( En t i = 0 ; i < productos químicos. tamaño ( ) ; i ++ )

      corte << quimicos [ i ] << fin ;

}

Producción:

Ahora, el vector final contiene cuatro elementos después de agregar “Manganeso” y “Cobre”.

Elemento máximo de un vector

  1. Crea un vector con algunos elementos.
  2. Para encontrar el elemento máximo que está presente en el vector, use la función *max_element() que acepta dos iteradores como argumentos. Estos dos parámetros actúan como rango y el elemento máximo se devuelve dentro del rango proporcionado. La posición inicial es comenzar() y la última posición es finalizar().
* elemento_max ( primer_índice, último_índice )

Consideremos un vector llamado 'item_costs' que contiene cinco valores de tipo entero y devuelve el elemento máximo.

#incluir

#incluir

#incluir

usando espacio de nombres enfermedad de transmisión sexual ;

principal ( )

{

    // Crear vector - item_costs

vector < En t > costos_artículo = { 8900 , 5677 , 200 , 1000 , 2300 } ;

 

    corte << 'Costo de los artículos: \norte ' ;

    para ( En t i = 0 ; i < costos_artículo. tamaño ( ) ; i ++ )

        corte << costos_artículo [ i ] << fin ;

 

  // Devuelve el elemento máximo del vector anterior - item_costs

  corte << ' \norte Costo Máximo: ' << * elemento_max ( comenzar ( costos_artículo ) ,fin ( costos_artículo ) ) ;

}

Producción:

Aquí, 8900 es el elemento máximo entre todos los elementos que están presentes en el vector 'item_costs'.

Elemento mínimo de un vector

  1. Crea un vector con algunos elementos.
  2. Para encontrar el elemento mínimo que está presente en el vector, use la función *min_element() que acepta dos iteradores como argumentos. Estos dos parámetros actúan como rango y el elemento mínimo (menos que todos los demás elementos) se devuelve dentro del rango proporcionado. La posición inicial es comenzar() y la última posición es finalizar().
* elemento_min ( primer_índice, último_índice )

Utilice el mismo vector que se crea para encontrar el elemento máximo y encuentre el elemento mínimo usando la función *min_element().

#incluir

#incluir

#incluir

usando espacio de nombres enfermedad de transmisión sexual ;

principal ( )

{

    // Crear vector - item_costs

vector < En t > costos_artículo = { 8900 , 5677 , 200 , 1000 , 2300 } ;

 

    corte << 'Costo de los artículos: \norte ' ;

    para ( En t i = 0 ; i < costos_artículo. tamaño ( ) ; i ++ )

        corte << costos_artículo [ i ] << fin ;

 

  // Devuelve el elemento mínimo del vector anterior - item_costs

  corte << ' \norte Costo Mínimo: ' << * elemento_min ( comenzar ( costos_artículo ) ,fin ( costos_artículo ) ) ;

}

Producción:

Aquí, 200 es el elemento mínimo entre todos los elementos que están presentes en el vector 'item_costs'.

Suma de elementos en un vector

Para devolver la suma de todos los elementos que están presentes en el vector, el acumular() Se utiliza la función en C++ STL. Acepta tres parámetros. El primer parámetro toma el primer índice que representa el elemento inicial en el rango (especifique el iterador de inicio()) y el segundo parámetro toma el último índice que representa el elemento final en el rango (especifique el iterador de fin()). Por último, debemos pasar el valor inicial de la suma (en nuestro caso, es 0).

acumular ( primer_índice, último_índice, valor_inicial ) ;

Cree un vector llamado 'item_costs' con cinco elementos de tipo entero y calcule la suma.

#incluir

usando espacio de nombres enfermedad de transmisión sexual ;

principal ( )

{

    // Crear vector - item_costs

vector < En t > costos_artículo = { 8900 , 5677 , 200 , 1000 , 2300 } ;

 

    corte << 'Costo de los artículos: \norte ' ;

    para ( En t i = 0 ; i < costos_artículo. tamaño ( ) ; i ++ )

        corte << costos_artículo [ i ] << fin ;

 

  // Devuelve la suma de todos los elementos en el vector anterior - item_costs

  corte << ' \norte Coste total: ' << acumular ( comenzar ( costos_artículo ) ,fin ( costos_artículo ) , 0 ) ;

}

Producción:

La suma de 8900, 5677, 200, 1000, 2300 es 18077.

Multiplicación por elementos de dos vectores

  1. Cree dos vectores de tipo numérico y dos vectores deben ser del mismo tamaño (número total de elementos presentes en el primer vector = número total de elementos presentes en el segundo vector).
  2. Declare un nuevo vector y use el en bucle , realice la operación de multiplicación en dos elementos en cada iteración y almacene el valor en el vector creado usando la función push_back().
  3. para ( En t itr = 0 ; i < primer_vec. tamaño ( ) ; itr ++ )

    {

    vector_resultado. hacer retroceder ( primer_vec [ itr ] * cosa_seg [ itr ] ) ;

    }
  4. Muestra los elementos que están presentes en el vector resultante iterándolo.

Cree un vector llamado 'item_costs' con cinco elementos de tipo entero y calcule la suma.

#incluir

usando espacio de nombres enfermedad de transmisión sexual ;

principal ( )

{

    // Crea dos vectores: productos1 y productos2 con 5 elementos cada uno

vector < En t > productos1 = { 10 , 20 , 30 , 40 , 50 } ;

vector < En t > productos2 = { 50 , 40 , 30 , 70 , 60 } ;

 

vector < En t > resultados_productos ;

 

    // Realizar multiplicación por elementos

    para ( En t i = 0 ; i < productos1. tamaño ( ) ; i ++ ) {

resultados_productos. hacer retroceder ( productos1 [ i ] * productos2 [ i ] ) ;

    }

 

    // Muestra el vector resultante

    corte << 'Multiplicación de vectores: \norte ' ;

    para ( En t res : resultados_productos )

        corte << res << fin ;

}

Producción:

Iteración - 1 : 10 * 50 => 500

Iteración - 2 : 20 * 40 => 800

Iteración - 3 : 30 * 30 => 900

Iteración - 4 : 40 * 70 => 2800

Iteración - 5 : 50 * 60 => 3000

Producto escalar de dos vectores

En el caso de vectores C++, el producto escalar se define como la “suma de los productos de las entradas correspondientes de las dos secuencias de vectores”.

Sintaxis:

producto Interno ( Vector1 primero, Vector1 último, Vector2 primero, Valor_inicial )

Utilice la función internal_product() para devolver el producto escalar. Esta función toma cuatro parámetros requeridos.

Aquí:

  1. El primer parámetro se refiere a un iterador que apunta al comienzo del primer vector (especifique usando la función comenzar()).
  2. El segundo parámetro se refiere a un iterador que apunta al final del primer vector (especifique usando la función end()).
  3. El tercer parámetro se refiere a un iterador que apunta al comienzo del segundo vector (especifique usando la función comenzar()).
  4. El valor inicial debe pasarse como último parámetro, que es un número entero para la acumulación del producto escalar.

Utilice el mismo programa creado para la multiplicación de dos vectores y utilice la función innsr_product() para encontrar el producto escalar de los dos vectores.

#incluir

usando espacio de nombres enfermedad de transmisión sexual ;

principal ( )

{

    // Crea dos vectores: productos1 y productos2 con 5 elementos cada uno

vector < En t > productos1 = { 10 , 20 , 30 , 40 , 50 } ;
   
vector < En t > productos2 = { 50 , 40 , 30 , 70 , 60 } ;

 

    // Muestra el vector resultante

    corte << 'Producto escalar de productos1 y productos2: ' ;

    corte << producto Interno ( comenzar ( productos1 ) ,fin ( productos1 ) ,comenzar ( productos2 ) , 0 ) ;

}

Producción:

( 10 * 50 ) + ( 20 * 40 ) + ( 30 * 30 ) + ( 40 * 70 ) + ( 50 * 60 )

=> 500 + 800 + 900 + 2800 + 3000

=> 8000

Convertir un conjunto en un vector

Hay muchas formas de convertir un conjunto en un vector pasando todos los elementos que se plantean en un conjunto a un vector. La mejor y más sencilla forma es utilizar la función std::copy().

Sintaxis

enfermedad de transmisión sexual :: Copiar ( sourceIterator primero, sourceIterator último, destinoIterator primero )

Utilizar el std::copiar() Función que inserta los elementos de un conjunto en el vector. Se necesitan tres parámetros.

Aquí:

  1. El primer parámetro se refiere al iterador de origen que apunta al primer elemento del iterador. Aquí, set es el iterador de origen que se especifica mediante la función comenzar().
  2. De manera similar, el segundo parámetro apunta al último elemento (función end()).
  3. El tercer parámetro hace referencia al iterador de destino que apunta al primer elemento (especificado mediante la función comenzar()) en el iterador.

Creemos un conjunto con cinco estudiantes y copiemos todos los elementos en un vector usando la función anterior.

#incluir

usando espacio de nombres enfermedad de transmisión sexual ;

principal ( )

{

    // Crea un conjunto - estudiantes con 5 elementos

colocar < cadena > estudiantes = { 'Sravan' , 'Poli' , 'Madhu' , 'Megana' , 'Lavanya' } ;

  corte << 'Colocar: \norte ' ;

    para ( cuerda yo : estudiantes )

        corte << i << fin ;

 

    // Crear vector - Student_vcof tamaño igual al tamaño del conjunto

vector < cadena > estudiante_vc ( estudiantes. tamaño ( ) ) ;

 

    // Insertar elementos de un Conjunto - estudiantes en un Vector - estudiante_vc.

Copiar ( estudiantes. comenzar ( ) , estudiantes. fin ( ) , estudiante_vc. comenzar ( ) ) ;

 

    corte << ' \norte Vector: \norte ' ;

    para ( cuerda yo : estudiante_vc )

        corte << i << fin ;

}

Producción:

Ahora, todos los elementos que están presentes en el conjunto 'Estudiantes' se copian en el vector 'students_vc'.

Eliminar los elementos duplicados

  1. Primero, necesitamos ordenar los elementos en el vector para que todos los elementos duplicados sean adyacentes entre sí usando el std::ordenar() función.
  2. enfermedad de transmisión sexual :: clasificar ( Vector primero, Vector último ) ;
  3. Utilice la función std::unique() para que se seleccionen los elementos duplicados. Al mismo tiempo, utilice la función erase() para eliminar los duplicados que devuelve la función std::unique(). El orden de los elementos puede cambiar en el vector final.
  4. vector. borrar ( enfermedad de transmisión sexual :: único ( Vector primero, Vector último ) , último vector ) )

Cree el vector 'estudiantes' con 10 elementos y devuelva el vector eliminando los duplicados.

#incluir

usando espacio de nombres enfermedad de transmisión sexual ;

principal ( )

{

    // Crea un vector - estudiantes con 10 elementos

vector < cadena > estudiantes = { 'Sravan' , 'Poli' , 'Madhu' , 'Megana' , 'Lavanya' ,

                              'Sravan' , 'Poli' , 'Madhu' , 'Megana' , 'Lavanya' } ;

  corte << 'Estudiantes: \norte ' ;

    para ( cuerda yo : estudiantes )

        corte << i << ' ' ;

 

  // Ordena todos los elementos en el vector de estudiantes.

clasificar ( comenzar ( estudiantes ) , fin ( estudiantes ) ) ;

 

  // Usa la función única() para eliminar los duplicados con la función erase()

estudiantes. borrar ( único ( comenzar ( estudiantes ) , fin ( estudiantes ) ) , fin ( estudiantes ) ) ;

 

  corte << ' \norte \norte Estudiantes únicos: \norte ' ;

    para ( auto itr = comenzar ( estudiantes ) ; itr ! = algunos ( estudiantes ) ; ++ itr ) {

        corte << * itr << ' ' ;

    }

}

Producción:

Ahora, todos los elementos son únicos en el vector.

Convertir un vector en un conjunto

Set no permite elementos duplicados. Si está escribiendo para insertar un vector en un conjunto con duplicados, se ignorarán. Usamos la misma función std::copy() que se usó en el escenario anterior que convirtió el conjunto en un vector.

En este escenario:

  1. El primer parámetro toma el vector como iterador de origen que se especifica mediante la función comenzar().
  2. El segundo parámetro toma el vector como iterador de origen que se especifica mediante la función end().
  3. Pase la función std::inserter() que se utiliza para sobrescribir/copiar los elementos automáticamente en una posición específica en el conjunto proporcionando el conjunto y el iterador que apuntan al final del conjunto como parámetros.

Creemos un vector con 10 números enteros y copiemos los elementos en un conjunto.

#incluir

usando espacio de nombres enfermedad de transmisión sexual ;

principal ( )

{

    // Crea un conjunto - marcas con 10 valores

vector < En t > marcas = { 12 , 34 , 56 , 78 , 65 , 78 , 90 , 90 , 78 , 34 } ;

  corte << 'Vector: \norte ' ;

    para ( En t i : marcas )

        corte << i << ' ' ;

 

    // Crear conjunto - conjunto de marcas de tamaño igual al tamaño del vector

colocar < En t > conjunto_marcas ;

 

    // Insertar elementos de un Conjunto - estudiantes en un Vector - estudiante_vc.

Copiar ( comenzar ( marcas ) ,fin ( marcas ) , insertador ( conjunto_marcas, fin ( conjunto_marcas ) ) ) ;

 

    corte << ' \norte \norte Colocar: \norte ' ;

    para ( En t i : conjunto_marcas )

        corte << i << ' ' ;

}

Producción:

El vector existente denominado 'marcas' tiene 10 valores. Después de copiarlo en el conjunto 'marks_set', solo contiene seis elementos porque los otros cuatro elementos están duplicados.

Eliminar las cadenas vacías

No se utilizan cadenas vacías que estén presentes en un vector. Es una buena práctica eliminar las cadenas vacías que están presentes en el vector. Veamos cómo eliminar las cadenas vacías del vector de C++:

  1. Itere el vector usando el bucle 'for'.
  2. En cada iteración, verifique si el elemento está vacío (“”) o no usa el operador “==” con la función miembro at().
  3. Usando la función std::erase(), elimine las cadenas vacías después de verificar la condición anterior.
  4. Repita los pasos 2 y 3 hasta el final del vector.

Creemos el vector 'empresas' con 10 cadenas. Entre ellos, cinco están vacíos y los eliminamos implementando el enfoque anterior.

#incluir

#incluir

usando espacio de nombres enfermedad de transmisión sexual ;

principal ( ) {

 

vector < cadena > compañías { 'Empresa-A' , '' , 'Empresa-B' ,

                              '' , 'Empresa-C' , '' , 'Company-D' , '' , '' , '' } ;

 

    // Iterar sobre empresas

    // y eliminar elementos vacíos usando erase()

    para ( En t itr = 1 ; itr < compañías. tamaño ( ) ; ++ itr ) {

      si ( compañías. en ( itr ) == '' ) {

compañías. borrar ( compañías. comenzar ( ) + itr ) ;

      -- itr ;

      }
    }
 
    // Muestra el vector


    para ( auto & i : compañías ) {

      corte << i << fin ;

    }

}

Producción:

Ahora, el vector 'empresas' contiene las cadenas no vacías.

Escribir un vector en un archivo de texto

Analicemos cómo escribir todos los elementos que están presentes en un vector en un archivo usando los índices vectoriales usando el fstream .

  1. Inserte algunos elementos usando la función push_back después de inicializar el vector.
  2. Utilice la función open() de la biblioteca “fstream” con el modo out.
  3. Recorre cada elemento que está presente en el vector usando los índices en un bucle 'for' y escribe cada elemento en el archivo proporcionado.
  4. Finalmente, cierre el archivo.

Implementemos el enfoque anterior ejecutando un código C++.

#incluir

#incluir

#incluir

#incluir

usando espacio de nombres enfermedad de transmisión sexual ;

principal ( )

{

    // Crea un vector - v_data

    // e inserta dos elementos en él.

vector < cadena > v_datos ;

v_datos. hacer retroceder ( 'Bienvenido' ) ;

v_datos. hacer retroceder ( 'a LinuxSugerencia' ) ;

corriente f ;

 

    // Abre el archivo

F. abierto ( 'archivo_escrito.txt' ,ios_base :: afuera ) ;

    // Itera cada elemento del vector y escribe en el archivo uno por uno.

    para ( En t i = 0 ; i < v_datos. tamaño ( ) ; i ++ )

    {

F << v_datos [ i ] << fin ;

    }

    //Cerrar el archivo

F. cerca ( ) ;

}

Producción:

El vector “v_data” contiene dos elementos y se crea un archivo en la ruta donde se ejecuta el programa con los elementos que están presentes en el vector.

Crear un vector a partir de un archivo de texto

Aprendimos a escribir los elementos que están presentes en el vector en un archivo de texto. Aquí, creemos un vector a partir del contenido que está presente en el archivo de texto.

  1. Crear un ' si corriente” Variable que se utiliza para leer la información del archivo de texto en el que creamos el vector a partir del archivo.
  2. Cree un vector vacío para almacenar el contenido del archivo y use una variable de cadena vacía como bandera para verificar el final del archivo.
  3. Lea la siguiente línea del archivo hasta que llegue al final (básicamente usando el bucle ' while'). Utilice la función push_back() para leer la siguiente línea e insertarla en el vector.
  4. Muestre la línea que está presente en la línea por separado para ver los elementos que están presentes en el vector en la consola.

Implementemos el enfoque anterior ejecutando el código C++. Consideremos el archivo 'data.txt' con el siguiente contenido. Aquí, el nombre del vector es 'v_data'.

#incluir

usando espacio de nombres enfermedad de transmisión sexual ;

principal ( )

{

    // Abre el archivo de texto - datos
archivo ifstream ( 'datos.txt' ) ;
   
    // Crea vector - v_data de tipo - cadena


vector < cadena > v_datos ;

tanga era ;

    // Lee la siguiente línea del data.txt
    // hasta llegar al final.


    mientras ( archivo >> era ) {

    // Lee la siguiente línea y presiona en v_data

v_datos. hacer retroceder ( era ) ;

}

 

    // Muestra la línea presente en la línea por separado.

Copiar ( v_datos. comenzar ( ) , v_datos. fin ( ) , ostream_iterador < cadena > ( corte , ' \norte ' ) ) ;

}

Producción:

Podemos ver que 'v_data' contiene cinco elementos que provienen del archivo.

Conclusión

En este largo artículo, exploramos todos los ejemplos posibles que se utilizan en aplicaciones en tiempo real relacionadas con vectores en el lenguaje de programación C++. Cada ejemplo se explica con sintaxis, parámetros y ejemplo con resultado. Se agregan comentarios en cada código para obtener una comprensión clara del código.