¿Cómo elimino un elemento específico de un vector en c?++?

El vector C ++ tiene muchas funciones miembros. Dos de estas funciones de miembros son borrados () y pop_back (). pop_back () elimina el último elemento del vector. Para eliminar todos los elementos del vector, usando pop_back (), la función pop_back () debe repetirse el número de veces que hay elementos. La función ERASE () puede eliminar un elemento desde el principio, dentro o el final del vector. Para eliminar todos los elementos del vector, usando ERASE (), la función ERASE () debe repetirse el número de veces que hay elementos, comenzando desde el primer elemento.

Para eliminar un elemento específico del vector C ++, el elemento debe identificarse. Con respecto a la función de miembro Erase (), el elemento es identificado por un iterador. La siguiente pregunta es: "¿Qué es un iterador??" - vea abajo. Dado que la función miembro pop_back () elimina el último elemento por definición, el elemento específico que tiene que eliminar ya se ha identificado indirectamente.

Para usar la biblioteca vectorial en C ++, el programa debe comenzar con:

#incluir
#incluir
usando el espacio de nombres STD;

Este artículo explica cómo eliminar un elemento específico del vector C ++, comenzando con la explicación del principal iterador en C++. Todo el código vectorial para este artículo está en el cuerpo de la función principal ().

Contenido del artículo

• Introducción - Ver arriba
• Identificación del elemento vectorial
• Eliminar con borrado ()
• Eliminar con pop_back
• Conclusión

Identificación del elemento vectorial

Identificación por referencia
Considere el siguiente vector:

vector vtr = 'a', 'b', 'c', 'd', 'e';

VTR [0] Devuelve 'A'. VTR [1] Devuelve 'B'. VTR [2] Devuelve 'C'. VTR [3] Devuelve 'D'. VTR [4] Devuelve 'E'. Esto se identifica por referencia. El número en los soportes cuadrados se llama índice. Se puede hacer en un bucle for-loop, como muestra el siguiente programa:

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

vector vtr = 'a', 'b', 'c', 'd', 'e';
para (int i = 0; icout << vtr[i] << ";
cout << endl;
regresar 0;

La salida es:

A B C D E

Identificación por iterador
Considere el siguiente vector:

vector vtr = 'a', 'b', 'c', 'd', 'e';

IT = VTR.begin (), significa que 'it' es un iterador que apunta a 'a' .

++ señala 'b'.

++ puntos a 'C', incrementado después de que apuntaba a 'B'.

Se apunta ++ a 'D', incrementado después de que estaba apuntando a 'C'.

++ apunta a 'e', ​​incrementado después de que apuntaba a 'd'.

++ puntos a VTR.End (), que está más allá del último elemento, se incrementa después de señalar 'e'.

Esto se puede hacer en un bucle for-loop, como muestra el siguiente programa:

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

vector vtr = 'a', 'b', 'c', 'd', 'e';
para (vector :: iterator it = vtr.comenzar(); él != VTR.fin(); IT ++)
cout << *it << ";
cout << endl;
regresar 0;

La salida es:

A B C D E

El primer iterador fue recibido con la declaración:

vector :: iterador it

donde 'it' es el identificador del iterador.

Todavía refiriéndose al mismo vector,

IT = VTR.end (), puntos justo más allá del último elemento 'E' .

señala 'e'.

señala 'd', disminuido después de que apuntaba a 'e'.

señala 'c', disminuido después de que estaba apuntando a 'd'.

señala 'b', disminuido después de que apuntaba a 'c'.

señala 'a', disminuido después de que apuntaba a 'b'.

Este esquema se puede usar para mostrar el vector en orden inverso, como muestra el siguiente programa:

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

vector vtr = 'a', 'b', 'c', 'd', 'e';
vector :: iterator it = vtr.fin();
para (it = --it; it> = vtr.comenzar(); él--)
cout << *it << ";
cout << endl;
regresar 0;

La salida es:

E D C B A

El iterador inicial para el bucle de for-bucle está disminuido. i.mi. "It = -it;". Tenga en cuenta la condición de tiempo para el for-bucle, yo.mi. "It> = VTR.comenzar();".

Para obtener el valor apuntado por el iterador, el iterador debe ser desactivado por el operador de indirección, *.

Eliminar con borrado ()

La sintaxis para borrar (eliminar) un elemento de un vector es:

a.borrar (Q)

donde 'a' es el nombre del vector, y Q es un iterador que apunta al elemento a eliminar. Es decir, Q identifica el elemento específico que se eliminará. La función miembro devuelve un iterador que apunta al elemento justo después de que se elimine el uno.

Retirando del frente
La función de miembro borrado puede eliminar un elemento del frente del vector. El siguiente programa ilustra esto:

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

vector vtr = 'a', 'b', 'c', 'd', 'e';
vector :: iterator q = vtr.comenzar();
vector :: iterador p = vtr.borrar (q);
cout << *p << endl;
para (int i = 0; i < vtr.size(); i++)
cout << vtr[i] << ";
cout << endl;
para (vector :: iterator it = vtr.comenzar(); él != VTR.fin(); IT ++)
cout << *it << ";
cout << endl;
regresar 0;

La salida es:

B
B C D E
B C D E

Las dos primeras líneas en el programa incluyen directivas, incluidas las bibliotecas necesarias. La siguiente línea declara que cualquier nombre utilizado es desde el espacio de nombres estándar a menos que se indique lo contrario.

En la función main (), la primera declaración declara el vector. La declaración después de devolver un iterador, Q, que apunta al primer elemento del vector. La declaración que sigue es la declaración de interés. Elimina el primer elemento, que se apunta por Q. Devuelve un iterador que apunta al elemento, que fue justo después de que el elemento fue eliminado. La declaración después de imprimir el valor del elemento al que apunta el iterador después de la eliminación. Los siguientes dos segmentos de código muestran los valores restantes en el vector. El primero de estos segmentos de código usa referencias. El segundo usa iteradores.

Eliminando desde adentro
Para eliminar el elemento de valor, 'c', el iterador devuelto, por begin () debe incrementarse dos veces para apuntar al elemento de valor, 'c'. La función miembro ERASE () puede usar el iterador para eliminar el elemento. El siguiente programa ilustra esto:

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

vector vtr = 'a', 'b', 'c', 'd', 'e';
vector :: iterator q = vtr.comenzar();
Q ++; Q ++;
vector :: iterador p = vtr.borrar (q);
cout << *p << endl;
para (int i = 0; i < vtr.size(); i++)
cout << vtr[i] << ";
cout << endl;
para (vector :: iterator it = vtr.comenzar(); él != VTR.fin(); IT ++)
cout << *it << ";
cout << endl;
regresar 0;

La salida es:

D
A B D E
A B D E

Eliminar de la parte posterior con borrado ()
Para eliminar el elemento de valor, 'e', ​​el iterador devuelto, al final () debe disminuir una vez, para apuntar al elemento de valor, 'e'. La función miembro ERASE () puede usar el iterador para eliminar el elemento. El siguiente programa ilustra esto:

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

vector vtr = 'a', 'b', 'c', 'd', 'e';
vector :: iterator q = vtr.fin();
Q--;
vector :: iterador p = vtr.borrar (q);
cout << *p << endl;
para (int i = 0; i < vtr.size(); i++)
cout << vtr[i] << ";
cout << endl;
para (vector :: iterator it = vtr.comenzar(); él != VTR.fin(); IT ++)
cout << *it << ";
cout << endl;
regresar 0;

La salida es:

mi
A B C D
A B C D

Hay un matiz aquí. El iterador devuelto por end () señala el elemento, que debería haber estado allí, si no se hubiera eliminado.

Eliminar con pop_back

La función miembro pop_back () elimina el último elemento del vector, por definición. Entonces, el programador no necesita identificar el último elemento. Su sintaxis es

a.pop_back ()

donde 'a' es el nombre del vector. No se necesita argumento; Devuelve nulo. El siguiente programa elimina el último elemento de un vector:

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

vector vtr = 'a', 'b', 'c', 'd', 'e';
VTR.pop_back ();
para (int i = 0; i < vtr.size(); i++)
cout << vtr[i] << ";
cout << endl;
para (vector :: iterator it = vtr.comenzar(); él != VTR.fin(); IT ++)
cout << *it << ";
cout << endl;
regresar 0;

La salida es:

A B C D
A B C D

Conclusión

El vector C ++ tiene muchas funciones miembros. Dos de estas funciones de miembros son borrados () y pop_back (). pop_back () elimina el último elemento del vector. Para eliminar todos los elementos del vector, usando pop_back (), la función pop_back () debe repetirse el número de veces que hay elementos. La función ERASE () puede eliminar un elemento desde el principio, dentro o el final del vector. Para eliminar todos los elementos del vector, usando ERASE (), la función ERASE () debe repetirse el número de veces que hay elementos, comenzando desde el primer elemento.

Para eliminar un elemento específico del vector C ++, el elemento debe identificarse. Para la función miembro ERASE (), el elemento es identificado por un iterador. Dado que la función miembro pop_back () elimina el último elemento por definición, el elemento específico que tiene que eliminar ya se ha identificado indirectamente.