¿Puedes eliminar un vector en c?++?

Sí! Sí, pero no va sin restricciones. Hay dos formas de eliminar un vector. De nuevo no van sin restricciones. Una forma de eliminar un vector es usar el destructor del vector. En este caso, todos los elementos se eliminan, pero el nombre del vector no se elimina. La segunda forma de eliminar un vector es simplemente dejarlo salir del alcance. Normalmente, cualquier objeto no estático declarado en un alcance muere cuando sale del alcance. Esto significa que no se puede acceder al objeto en un alcance de anidación (bloque). Un alcance de anidación es un alcance externo (bloque). Un alcance anidado es un alcance interno, que sigue siendo parte del alcance de interés. Estas dos formas de eliminar un vector se discuten en este artículo.

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

#incluir
#incluir
usando el espacio de nombres STD;

Contenido del artículo

• Destruyendo el vector
• Dejar salir del alcance
• Conclusión

Destruyendo el vector

Cualquier objeto creado está en algún alcance. El vector se crea y destruye en el alcance de la función principal () en esta sección del artículo. La sintaxis para destruir un vector es:

a.~ X ()

donde 'a' es el nombre del vector, y x es el nombre de clase del vector. El vector es una estructura de datos instanciada desde una clase. El nombre de la clase vectorial es "vector", con todos los personajes en minúsculas. Si el nombre del vector es VTR, entonces el vector se destruiría con,

VTR.~ vector.

El siguiente programa elimina el vector:

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

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

cout << endl;
regresar 0;

La salida no es nada, que indica que todos los elementos vectoriales, excepto el nombre del vector, se han borrado. Eso está bien. La salida anterior se mostró haciendo referencia a los supuestos elementos. ¿Qué pasa si la salida se muestra usando el iterador?? Considere el siguiente programa:

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

vector vtr = 'a', 'b', 'c', 'd', 'e';
vector:: iterator it = vtr.comenzar();
VTR.~ vector ();
para (it = it; it != VTR.fin(); it ++)
cout << *it << ";

cout << endl;
regresar 0;

La salida todavía no es nada. En esta etapa, es seguro concluir realmente que cuando se destruye un vector, todos sus elementos son destruidos, excepto su nombre.

Nombre vector no destruido

Dado que el nombre del vector no se destruye con el destructor, el nombre aún se puede reutilizar en el mismo alcance. El siguiente programa ilustra esto:

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

vector vtr = 'a', 'b', 'c', 'd', 'e';
VTR.~ vector ();
vtr = 'f', 'g', 'h', 'i', 'j';
para (int i = 0; i < vtr.size(); i++)
cout << vtr[i] << ";

cout << endl;
regresar 0;

La salida es:

F G H I J

El contenido original del vector tenía 5 caracteres. Los 5 elementos fueron borrados. Como el nombre del vector se reutilizó, se dieron 5 caracteres nuevos como contenido para el vector. La salida mostró que el nuevo contenido era correcto.

Sin embargo, todavía hay un matiz. Si el nuevo contenido se da con la función miembro push_back (), la salida puede estar incompleta y puede haber nuevos caracteres en el vector. El siguiente programa ilustra esto:

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

vector vtr = 'a', 'b', 'c', 'd', 'e';
VTR.~ vector ();
vtr = 'v', 'w', 'x', 'y', 'z';
VTR.~ vector ();
VTR.push_back ('f');
VTR.push_back ('g');
VTR.push_back ('h');
VTR.push_back ('i');
VTR.push_back ('j');
para (int i = 0; i < vtr.size(); i++)
cout << vtr[i] << ";

cout << endl;
regresar 0;

La salida es:

p ^ t e u g h i j

Falta 'f' en la salida, y hay caracteres extraños. Inicialmente, el contenido vectorial se proporciona utilizando el operador de asignación. El vector se destruye y se asigna nuevo contenido con el operador de asignación. El vector se destruye nuevamente, y esta vez el contenido se da con la función miembro push_back (). Falta 'f' en la salida, y hay caracteres extraños. Esto necesita explicación:

Cuando se destruye un vector, todos sus elementos se borran oficialmente. Lo que sucede es que los elementos simplemente se consideran que no pertenecen al vector con efecto inmediato, y sus ubicaciones de memoria están destinadas a cualquier otro código, con efecto inmediato. Si este esquema no se lleva a cabo perfectamente internamente, como con el último programa anterior, entonces habrá problemas, y el tipo de salida obtenido anteriormente puede resultar en.

vector constante

Cuando Const, por constante, se precede a una declaración vectorial, como se puede destruir, como se explicó anteriormente. El siguiente programa ilustra esto:

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

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

cout << endl;
regresar 0;

La salida no es nada. Sin embargo, bajo esta condición (const vector), no se puede borrar ningún elemento utilizando la función de miembro ERASE ().

Usar el nombre en un alcance anidado

Destruir un vector con ~ vector destruye el contenido (elementos) pero no el nombre del vector. El nombre aún se puede usar en un alcance interno, que todavía es parte del alcance de interés. El siguiente programa ilustra esto:

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

vector vtr = 'a', 'b', 'c', 'd', 'e';
VTR.~ vector ();
if (1 == 1)
vtr = 'k', 'l', 'm', 'n', 'o';
para (int i = 0; i < vtr.size(); i++)
cout << vtr[i] << ";
cout << endl;

regresar 0;

La salida es:

K L M N O

NOTA: Si se debe reutilizar un nombre vectorial, no debe volver a decarse.

Dejar salir del alcance

Cuando cualquier objeto declarado sale de su alcance, ya no se puede acceder de su alcance. Esto significa que ya no se puede acceder en un alcance de anidación. Sin embargo, se puede acceder en un alcance anidado. Un alcance anidado sigue siendo parte del alcance en cuestión.

Acceso dentro y fuera del alcance

El siguiente programa ilustra cómo se accede a un vector en el alcance:

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

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

regresar 0;

La salida es:

A B C D E

El alcance de la función principal () nesta el alcance if-bloque. VTR declaró en el alcance if-bloqueo solo se puede acceder en el alcance if-bloque. No se puede acceder fuera del alcance de if-bloque. No se puede acceder afuera en el bloque de funciones main () que anida el bloque if. El siguiente programa no se compilará, ya que se intenta acceder al vector fuera de su alcance:

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

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

cout << vtr[1] << endl;
regresar 0;

Si el lector intentara compilar el programa, se habría emitido un mensaje de error.

Alcance anidado

Un alcance anidado sigue siendo parte del alcance en cuestión. El siguiente programa ilustra cómo se puede acceder a un vector en un alcance anidado:

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

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


regresar 0;

La salida es:

A B C D E

El bloque de función Main () nesta el primer bloque if, que anida el segundo bloque if. El vector se declara en el primer bloque if. Se ha accedido en el anidado (interno) if-bloque.

El enfoque de dejar que el vector muera a medida que sale del alcance se ve preferible en comparación con el uso del destructor. Cuando el vector sale de alcance, su nombre también muere. Sin embargo, no es todo el tiempo que el programador quiera que el vector muera al salir de alcance. Entonces el destructor tendrá que usarse ocasionalmente. Ambas formas tienen sus limitaciones.

Conclusión

Una forma de eliminar un vector es usar el destructor del vector. En este caso, todos los elementos se eliminan, pero el nombre del vector no se elimina. La segunda forma de eliminar un vector es simplemente dejarlo salir del alcance. Normalmente, cualquier objeto no estático declarado en un alcance muere cuando sale del alcance. Esto significa que no se puede acceder al objeto en un alcance de anidación (bloque). Un alcance de anidación es un alcance externo (bloque). Sin embargo, se puede acceder en un alcance anidado. Un alcance anidado es un alcance interno, que sigue siendo parte del alcance de interés. Ambas formas tienen restricciones. Un vector en un alcance interno no necesita ser destruido con ~ vector antes de dejar que salga del alcance para morir.