Vector C ++ Clear vs Borrar

El vector C ++ tiene muchas funciones miembros. Dos de ellos son clare () y borrar (). claro() "Elimina" todos los elementos del vector. borrar () "elimina" un solo elemento o un rango de elementos. Hay dos variantes sobrecargadas de la función miembro ERASE () para el vector.

El título de este artículo es en realidad "Función de miembro vectorial () versus vector e Erase () Función miembro, en C ++". Esta es una comparación de las funciones de dos miembros. Se trata de cuándo usar cuál, cómo usar cuál y las condiciones se usan.

Para usar un vector en un programa C ++, el programa debe comenzar con:

#incluir
#incluir
usando el espacio de nombres STD;

Contenido del artículo

• Vector claro ()
• Borrar
• Pop_back
• Destruir un vector
• Conclusión

Vector claro ()

La función miembro clara () "elimina" todos los elementos del vector. Su sintaxis es:

nulo claro ()

Devuelve nulo. El siguiente programa ilustra su uso, con la expresión, "VTR.claro();":

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

vector vtr = 'p', 'q', 'r', 's', 't', 'u';
para (vector:: iterator it = vtr.comenzar(); él != VTR.fin(); IT ++)
cout << *it << ";
cout << endl;
VTR.claro();
para (vector:: iterator it = vtr.comenzar(); él != VTR.fin(); IT ++)
cout << *it << ";
cout << endl;
regresar 0;

La salida es la línea única:

P Q R S T U

Si el vector no hubiera sido borrado, la salida habría sido dos líneas de la misma secuencia. No se mostró una segunda línea porque todos los elementos fueron despejados.

const vector y clear ()

Cuando una declaración de vector está precedida por const, significa que los elementos del vector no se pueden eliminar o cambiar. Si una expresión intenta cambiar o eliminar cualquiera de los elementos, el programa no se compilará. Pruebe el siguiente programa y tenga en cuenta que no compila:

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

vector constante vtr = 'p', 'q', 'r', 's', 't', 'u';
para (vector:: const_iterator it = vtr.comenzar(); él != VTR.fin(); IT ++)
cout << *it << ";
cout << endl;
VTR.claro();
para (vector:: const_iterator it = vtr.comenzar(); él != VTR.fin(); IT ++)
cout << *it << ";
cout << endl;
regresar 0;

Si se probara el programa, se habría emitido un mensaje de error y no habría habido ninguna compilación. Debido a que el vector se declaró constante, la función Clear () no pudo funcionar, lo que resultó en un mensaje de error desde el compilador.

Nota: Clear () elimina todos los elementos del vector. En realidad, se destina a todos los elementos eliminados, de modo que otros códigos puedan ocupar sus ubicaciones de memoria. Si la ubicación de memoria de cualquier elemento aún no ha sido tomada por otro código, entonces el elemento aún se puede reutilizar en nombre del mismo vector.

Borrar

Las sintaxis simplificadas para las dos funciones miembros ERASE () son:

a.borrar (Q)
y
a.borrar (Q1, Q2)

donde a es el nombre del vector.

Borras de iterador (posición const_iterator)

Esta es la sintaxis completa para "A.borrar (q) ". Devuelve un iterador que apunta al elemento, que estaba justo detrás de uno borrado. El argumento, Q es un iterador que apunta al elemento a borrar. El siguiente programa ilustra esto:

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

vector vtr = 'p', 'q', 'r', 's', 't', 'u';
vector:: iterator iter = vtr.comenzar();
++iter; ++ iter;
vector:: iterator it = vtr.borrar (iter);
para (int i = 0; i < vtr.size(); i++)
cout << vtr[i] << ";

cout << endl;
cout << *it << endl;
regresar 0;

La salida es:

P q s t u
S

'R' ha sido eliminado. El iterador devuelto ahora señala 's', que fue justo después de 'r'. La función miembro, begin (), devuelve un iterador que apunta al primer elemento del vector. En el código, este iterador se incrementó dos veces para señalar 'R'. 'R' se borró con la expresión, "VTR.borrar (iter) ".

Rango en vector

Para la lista,

'P', 'Q', 'r', 's', 't', 'u'

La secuencia, 'Q', 'r', 's', 't' es un rango. Sin embargo, con los contenedores C ++, el último elemento, 't' no se considera parte del rango. Esto se indica en términos generales como:

[i, j)
o
[Q1, Q2)

'[' En este caso, significa que el primer elemento en la secuencia está incluido, y ')' significa que el último elemento no está incluido.

ERASE ITERATOR (const_iterator primero, const_iterator Último)

Esta es la sintaxis completa para "A.borrar (Q1, Q2) ". Devuelve un iterador que apunta al elemento, que estaba justo detrás del rango borrado. NOTA: El último elemento en el rango no se borra. Entonces, el iterador devuelto apuntará al último elemento del rango. Los argumentos Q1and Q2 son iteradores que señalan el primer y último elemento del rango. El siguiente programa ilustra esto:

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

vector vtr = 'p', 'q', 'r', 's', 't', 'u';
vector:: iterator itb = vtr.comenzar();
++itb;
vector:: iterator ite = vtr.fin();
--ite; --Ite;
vector:: iterator it = vtr.borrar (itb, ite);
para (int i = 0; i < vtr.size(); i++)
cout << vtr[i] << ";

cout << endl;
cout << *it << endl;
regresar 0;

La salida es:

P t u
T

'Q', 'r', 's' se han eliminado. El iterador devuelto ahora señala 't', que fue el último elemento en el rango de contenedores. La función miembro, end (), devuelve un iterador que apunta justo después del último elemento del vector. En el código, este iterador fue disminuido dos veces para señalar 't', el último elemento del rango. 'Q', 'r', 's' se eliminaron sin el último elemento, 't' en el rango, con la expresión, "VTR.borrar (itb, ite) ".

const vector y borrar ()

Si la declaración de un vector se precede a constante, para constante, entonces ninguno de sus elementos se puede borrar. El siguiente programa no se compilará, emitiendo un mensaje de error para el A.borrar (q) expresión:

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

vector constante vtr = 'p', 'q', 'r', 's', 't', 'u';
vector:: const_iterator iter = vtr.comenzar();
++iter; ++ iter;
vector:: const_iterator it = vtr.borrar (iter);
para (int i = 0; i < vtr.size(); i++)
cout << vtr[i] << ";

cout << endl;
cout << *it << endl;
regresar 0;

Si el lector probara el programa, habría recibido un mensaje de error. El programa no habría compilado.

El siguiente programa no se compilará, emitiendo un mensaje de error para el A.borrar la expresión (Q1, Q2):

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

vector constante vtr = 'p', 'q', 'r', 's', 't', 'u';
vector:: const_iterator itb = vtr.comenzar();
++itb;
vector:: const_iterator ite = vtr.fin();
--ite; --Ite;
vector:: const_iterator it = vtr.borrar (itb, ite);
para (int i = 0; i < vtr.size(); i++)
cout << vtr[i] << ";

cout << endl;
cout << *it << endl;
regresar 0;

Nota: Erase () elimina un elemento o un rango de elementos. En realidad, se destina a un elemento eliminado, de modo que sus ubicaciones de memoria puedan ser ocupadas por otros códigos. Si la ubicación de memoria de cualquier elemento aún no ha sido tomada por otro código, entonces el elemento aún se puede reutilizar en nombre del mismo vector.

pop_back ()

La función de miembro vectorial pop_back () es un tipo de función ERASE (). Sin embargo, elimina solo el último elemento del vector. La sintaxis es:

void pop_back ()

No requiere argumento y devuelve nulo. El siguiente programa ilustra su uso:

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

vector vtr = 'p', 'q', 'r', 's', 't', 'u';
VTR.pop_back ();
para (int i = 0; i < vtr.size(); i++)
cout << vtr[i] << ";

cout << endl;
regresar 0;

La salida es:

P Q R S T

El último elemento, 'u' ha sido eliminado (borrado).

Destruir un vector

¿Se puede destruir un vector?? - Sí! Sin embargo, cuando se destruye un vector, todos sus elementos se borran excepto su nombre; lo que significa que la declaración vectorial aún se puede reutilizar, pero con cierta incertidumbre. La sintaxis para destruir un vector es:

a.~ X ()

donde 'a' es el nombre del vector. El siguiente programa ilustra esto:

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

vector vtr = 'p', 'q', 'r', 's', 't', 'u';
VTR.~ vector ();
vtr = 'v', 'w', 'x', 'y', 'z';
para (int i = 0; i < vtr.size(); i++)
cout << vtr[i] << ";

cout << endl;
VTR.~ vector ();
VTR.push_back ('a');
VTR.push_back ('b');
VTR.push_back ('c');
VTR.push_back ('d');
VTR.push_back ('e');
para (int i = 0; i < vtr.size(); i++)
cout << vtr[i] << ";

cout << endl;
regresar 0;

La salida es:

V W X Y Z
p ^ t e @ a c d e

de la computadora del autor, con algunos personajes poco confiables para la segunda línea.

Conclusión

La función de miembro del vector Clear () se puede comparar con la función de miembro del vector ERASE (). No son sustitutos. Clear () elimina todos los elementos del vector. En realidad, se destina a todos los elementos eliminados, de modo que otros códigos puedan absorber sus ubicaciones de memoria. Si la ubicación de memoria de cualquier elemento aún no ha sido tomada por otro código, entonces el elemento aún se puede reutilizar en nombre del mismo vector. borrar () elimina un elemento o un rango de elementos. En realidad, se destina a un elemento eliminado, de modo que la ubicación de la memoria puede ser tomada por otro código. Si otro código aún no se ha tomado la ubicación de memoria de cualquier elemento eliminado, entonces el elemento aún se puede reutilizar en nombre del mismo vector. claro tiene similitud con destruir, ~ x ().