Pouvez-vous supprimer un vecteur en c++?

Oui! Oui, mais ça ne se passe pas sans contraintes. Il existe deux façons de supprimer un vecteur. Encore une fois, ils ne vont pas sans contraintes. Une façon de supprimer un vecteur est d'utiliser le destructeur du vecteur. Dans ce cas, tous les éléments sont supprimés, mais le nom du vecteur n'est pas supprimé. La deuxième façon de supprimer un vecteur est juste de le laisser sortir de la portée. Normalement, tout objet non statique déclaré dans une portée décède lorsqu'il sort de la portée. Cela signifie que l'objet ne peut pas être accessible dans une portée de nidification (bloc). Une lunette de nidification est une portée extérieure (bloc). Une lunette imbriquée est une portée intérieure, qui fait toujours partie de la portée d'intérêt. Ces deux façons de supprimer un vecteur sont discutées dans cet article.

Afin d'utiliser un vecteur en C ++, le programme doit commencer:

#inclure
#inclure
Utilisation de Namespace Std;

Contenu de l'article

• Détruire le vecteur
• Laisser sortir de la portée
• Conclusion

Détruire le vecteur

Tout objet créé est dans une portée. Le vecteur est créé et détruit dans la portée de la fonction principale () dans cette section de l'article. La syntaxe pour détruire un vecteur est:

un.~ X ()

où «a» est le nom du vecteur, et x est le nom de classe du vecteur. Le vecteur est une structure de données instanciée à partir d'une classe. Le nom de la classe vectorielle est «vecteur», avec tous les caractères en minuscules. Si le nom du vecteur est VTR, alors le vecteur serait détruit avec,

vtr.~ vecteur.

Le programme suivant supprime le vecteur:

#inclure
#inclure
Utilisation de Namespace Std;
int main()

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

couter << endl;
retour 0;

La sortie n'est rien, indiquant que tous les éléments vectoriels, à l'exception du nom du vecteur, ont été effacés. C'est bon. La sortie ci-dessus a été affichée en faisant référence aux éléments supposés. Et si la sortie est affichée en utilisant l'itérateur? Considérez le programme suivant:

#inclure
#inclure
Utilisation de Namespace Std;
int main()

vecteur vtr = 'a', 'b', 'c', 'd', 'e';
vecteur:: iterator it = vtr.commencer();
vtr.~ vector ();
pour (it = it; it != VTR.fin(); it ++)
couter << *it << ";

couter << endl;
retour 0;

La sortie n'est toujours rien. À ce stade, il est sûr de conclure vraiment que lorsqu'un vecteur est détruit, tous ses éléments sont détruits, sauf son nom.

Nom du vecteur non détruit

Étant donné que le nom du vecteur n'est pas détruit par le destructeur, le nom peut toujours être réutilisé dans la même portée. Le programme suivant illustre ceci:

#inclure
#inclure
Utilisation de Namespace Std;
int main()

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

couter << endl;
retour 0;

La sortie est:

F g h i j

Le contenu original du vecteur avait 5 caractères. Les 5 éléments étaient tous effacés. Comme le nom du vecteur a été réutilisé, de nouveaux 5 caractères ont été donnés en tant que contenu au vecteur. La sortie a montré que le nouveau contenu est correct.

Cependant, il y a encore une nuance. Si le nouveau contenu est donné avec la fonction de membre Push_back (), la sortie peut être incomplète et il peut y avoir de nouveaux caractères dans le vecteur. Le programme suivant illustre ceci:

#inclure
#inclure
Utilisation de Namespace Std;
int main()

vecteur 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');
pour (int i = 0; i < vtr.size(); i++)
couter << vtr[i] << ";

couter << endl;
retour 0;

La sortie est:

p ^ t e u g h i j

'F' est manquant dans la sortie, et il y a des caractères étranges. Initialement, le contenu vectoriel est donné à l'aide de l'opérateur d'affectation. Le vecteur est détruit et un nouveau contenu attribué à nouveau avec l'opérateur d'affectation. Le vecteur est à nouveau détruit, et cette fois le contenu est donné avec la fonction membre Push_back (). 'F' est manquant dans la sortie, et il y a des caractères étranges. Cela nécessite une explication:

Lorsqu'un vecteur est détruit, tous ses éléments sont officiellement effacés. Ce qui se passe, c'est que les éléments sont simplement considérés comme n'appartenant pas au vecteur avec effet immédiat, et leurs emplacements de mémoire sont affectés comme réutilisables par tout autre code, avec un effet immédiat. Si ce schéma n'est pas parfaitement réalisé en interne, comme pour le dernier programme ci-dessus, il y aura des problèmes, et le type de sortie obtenu ci-dessus peut en résulter.

vctor de constance

Lorsqu'une déclaration de vecteur est précédée par const, pour constante, il peut toujours être détruit, comme expliqué ci-dessus. Le programme suivant illustre ceci:

#inclure
#inclure
Utilisation de Namespace Std;
int main()

vctor de constance vtr = 'a', 'b', 'c', 'd', 'e';
vtr.~ vector ();
pour (int i = 0; i < vtr.size(); i++)
couter << vtr[i] << ";

couter << endl;
retour 0;

La sortie n'est rien. Cependant, dans cette condition (const vector), aucun élément ne peut être effacé en utilisant la fonction membre effacer ().

Utilisation du nom dans une portée imbriquée

Détruire un vecteur avec ~ vecteur détruit le contenu (éléments) mais pas le nom du vecteur. Le nom peut toujours être utilisé dans une portée intérieure, qui fait toujours partie de la portée d'intérêt. Le programme suivant illustre ceci:

#inclure
#inclure
Utilisation de Namespace Std;
int main()

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

retour 0;

La sortie est:

K l m n o

Remarque: si un nom de vecteur doit être réutilisé, il ne doit pas être reflété.

Laisser sortir de la portée

Lorsqu'un objet déclaré sort de sa portée, il ne peut plus être accessible de sa portée. Cela signifie qu'il ne peut plus être accessible dans une portée de nidification. Cependant, il est accessible dans une portée imbriquée. Une portée imbriquée fait toujours partie de la portée en question.

Accès à la portée et hors de l'échelle

Le programme suivant illustre comment un vecteur est accessible dans la portée:

#inclure
#inclure
Utilisation de Namespace Std;
int main()

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

retour 0;

La sortie est:

A b c d e

La portée de la fonction principale () niche la portée IF-bloc. VTR déclaré dans la lunette IF-bloc ne peut être accessible que dans la portée IF-Block. Il ne peut pas être accessible à l'extérieur de la portée IF-bloc. Il ne peut pas être accessible à l'extérieur dans le bloc fonction principal () qui niche le bloc if. Le programme suivant ne se compilera pas, car une tentative est faite pour accéder au vecteur en dehors de sa portée:

#inclure
#inclure
Utilisation de Namespace Std;
int main()

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

couter << vtr[1] << endl;
retour 0;

Si le lecteur tentait de compiler le programme, un message d'erreur aurait été émis.

Étendue imbriquée

Une portée imbriquée fait toujours partie de la portée en question. Le programme suivant illustre comment un vecteur est accessible dans une portée imbriquée:

#inclure
#inclure
Utilisation de Namespace Std;
int main()

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


retour 0;

La sortie est:

A b c d e

Le bloc fonction principal () niche le premier bloc IF, qui niche le deuxième bloc IF. Le vecteur est déclaré dans le premier bloc if. Il est accessible dans le bloc imbriqué (intérieur).

L'approche de laisser le vecteur mourir au fur et à mesure de la portée semble préférable par rapport à l'utilisation du destructeur. Lorsque le vecteur sort de portée, son nom décède également. Cependant, ce n'est pas tout le temps que le programmeur voudrait que le vecteur meure en sortant de la portée. Ainsi, le destructeur devra être utilisé de temps en temps. Les deux façons ont leurs contraintes.

Conclusion

Une façon de supprimer un vecteur est d'utiliser le destructeur du vecteur. Dans ce cas, tous les éléments sont supprimés, mais le nom du vecteur n'est pas supprimé. La deuxième façon de supprimer un vecteur est juste de le laisser sortir de la portée. Normalement, tout objet non statique déclaré dans une portée décède lorsqu'il sort de la portée. Cela signifie que l'objet ne peut pas être accessible dans une portée de nidification (bloc). Une lunette de nidification est une portée extérieure (bloc). Cependant, il est accessible dans une portée imbriquée. Une lunette imbriquée est une portée intérieure, qui fait toujours partie de la portée d'intérêt. Les deux façons ont des contraintes. Un vecteur dans une portée intérieure n'a pas besoin d'être détruit avec ~ vecteur avant de le laisser sortir de la portée pour mourir.