Comment supprimer un élément spécifique d'un vecteur en c++?

Le vecteur C ++ a de nombreuses fonctions membres. Deux de ces fonctions membres sont effacées () et pop_back (). pop_back () supprime le dernier élément du vecteur. Afin de supprimer tous les éléments du vecteur, en utilisant pop_back (), la fonction pop_back () doit être répétée le nombre de fois où il y a des éléments. La fonction effacer () peut supprimer un élément du début, à l'intérieur ou à la fin du vecteur. Afin de supprimer tous les éléments du vecteur, en utilisant effacer (), la fonction effacer () doit être répétée le nombre de fois où il y a des éléments, à partir du premier élément.

Afin de supprimer un élément spécifique du vecteur C ++, l'élément doit être identifié. Concernant la fonction de membre effacer (), l'élément est identifié par un itérateur. La question suivante est: «Qu'est-ce qu'un itérateur?" - voir ci-dessous. Puisque la fonction membre POP_BACK () supprime le dernier élément par définition, l'élément spécifique qu'il doit supprimer a déjà été identifié indirectement.

Pour utiliser la bibliothèque vectorielle en C ++, le programme doit commencer:

#inclure
#inclure
Utilisation de Namespace Std;

Cet article explique comment supprimer un élément spécifique du vecteur C ++, en commençant par expliquer l'itérateur principal en C++. Tout le code vectoriel pour cet article est dans le corps de fonction principale ().

Contenu de l'article

• Introduction - Voir ci-dessus
• Identification de l'élément vectoriel
• Retirer avec Erase ()
• Suppression avec POP_BACK
• Conclusion

Identification de l'élément vectoriel

Identification par référence
Considérez le vecteur suivant:

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

vtr [0] renvoie 'a'. vtr [1] renvoie 'b'. Vtr [2] renvoie 'C'. Vtr [3] renvoie 'D'. vtr [4] renvoie 'e'. Ceci s'identifie par référence. Le nombre en carré-crochets est appelé un index. Cela peut être fait dans une boucle, comme le montre le programme suivant:

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

vector vtr = 'a', 'b', 'c', 'd', 'e';
pour (int i = 0; icouter << vtr[i] << ";
couter << endl;
retour 0;

La sortie est:

A b c d e

Identification par itérateur
Considérez le vecteur suivant:

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

it = vtr.begin (), signifie «il» est un itérateur qui pointe vers «a» .

Il ++ pointe vers 'b'.

Il ++ pointe vers «c», incrémenté après qu'il pointe vers «b».

Il ++ pointe vers «D», incrémenté après qu'il pointe vers «C».

Il ++ pointe vers «e», incrémenté après qu'il pointe vers «D».

Il ++ pointe vers VTR.end (), qui est juste au-delà du dernier élément, incrémenté après avoir pointé vers «e».

Cela peut être fait dans une boucle, comme le montre le programme suivant:

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

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

La sortie est:

A b c d e

Le premier itérateur a été obtenu avec la déclaration:

Vector :: Iterator it

où «il» est l'identifiant de l'itérateur.

Se référant toujours au même vecteur,

it = vtr.end (), pointe juste au-delà du dernier élément 'e' .

Il indique «e».

Il indique «d», décrémenté après qu'il pointe vers «e».

Il indique «C», décrémenté après qu'il pointe vers «D».

Il indique «b», décrémentant après qu'il pointe vers «C».

Il indique «A», décrémenté après qu'il pointe vers «B».

Ce schéma peut être utilisé pour afficher le vecteur dans l'ordre inverse, comme le montre le programme suivant:

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

vector vtr = 'a', 'b', 'c', 'd', 'e';
vecteur :: iterator it = vtr.fin();
pour (it = --it; it> = vtr.commencer(); il--)
couter << *it << ";
couter << endl;
retour 0;

La sortie est:

E d c b a

L'itérateur initial de la boucle pour la boucle est décrémenté. je.e. «Il = -it;». Remarquez la condition de la boucle pour la boucle, je.e. «It> = vtr.commencer();".

Pour obtenir la valeur indiquée par l'itérateur, l'itérateur doit être déréféré, par l'opérateur d'indirection, *.

Retirer avec Erase ()

La syntaxe pour effacer (supprimer) un élément d'un vecteur est:

un.Effacer (Q)

où «a» est le nom du vecteur, et q est un itérateur pointant vers l'élément à supprimer. C'est-à-dire que q identifie l'élément spécifique à supprimer. La fonction membre renvoie un itérateur qui pointe vers l'élément juste après la suppression de celui.

Enlever de l'avant
La fonction de membre d'effacement peut supprimer un élément de l'avant du vecteur. Le programme suivant illustre ceci:

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

vector vtr = 'a', 'b', 'c', 'd', 'e';
vecteur :: iterator q = vtr.commencer();
vecteur :: iterator p = vtr.effacer (q);
couter << *p << endl;
pour (int i = 0; i < vtr.size(); i++)
couter << vtr[i] << ";
couter << endl;
pour (vector :: iterator it = vtr.commencer(); il != VTR.fin(); it ++)
couter << *it << ";
couter << endl;
retour 0;

La sortie est:

B
B c d e
B c d e

Les deux premières lignes du programme comprennent des directives, y compris les bibliothèques nécessaires. La ligne suivante déclare que tout nom utilisé provient de l'espace de noms standard, sauf indication contraire.

Dans la fonction principale (), la première instruction déclare le vecteur. La déclaration après renvoie un itérateur, Q, qui pointe vers le premier élément du vecteur. La déclaration qui suit est l'énoncé d'intérêt. Il supprime le premier élément, qui est indiqué par q. Il renvoie un itérateur qui pointe vers l'élément, qui était juste après la suppression de l'élément. L'énoncé après imprime la valeur de l'élément dans lequel l'itérateur pointe après la suppression. Les deux segments de code suivants affichent les valeurs restantes dans le vecteur. Le premier de ces segments de code utilise des références. Le second utilise des itérateurs.

Retirer de l'intérieur
Afin de supprimer l'élément de valeur, «C», l'itérateur est retourné, par début () doit être incrémenté deux fois pour pointer vers l'élément de valeur, «C». La fonction d'effacement () peut ensuite utiliser l'itérateur pour supprimer l'élément. Le programme suivant illustre ceci:

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

vector vtr = 'a', 'b', 'c', 'd', 'e';
vecteur :: iterator q = vtr.commencer();
q ++; q ++;
vecteur :: iterator p = vtr.effacer (q);
couter << *p << endl;
pour (int i = 0; i < vtr.size(); i++)
couter << vtr[i] << ";
couter << endl;
pour (vector :: iterator it = vtr.commencer(); il != VTR.fin(); it ++)
couter << *it << ";
couter << endl;
retour 0;

La sortie est:

D
A b d e
A b d e

Enlever de l'arrière avec Erase ()
Afin de supprimer l'élément de valeur, «e», l'itérateur est revenu, à la fin () doit être décrémenté une fois, pour pointer vers l'élément de valeur, «e». La fonction d'effacement () peut ensuite utiliser l'itérateur pour supprimer l'élément. Le programme suivant illustre ceci:

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

vector vtr = 'a', 'b', 'c', 'd', 'e';
vecteur :: iterator q = vtr.fin();
Q--;
vecteur :: iterator p = vtr.effacer (q);
couter << *p << endl;
pour (int i = 0; i < vtr.size(); i++)
couter << vtr[i] << ";
couter << endl;
pour (vector :: iterator it = vtr.commencer(); il != VTR.fin(); it ++)
couter << *it << ";
couter << endl;
retour 0;

La sortie est:

E
A B C D
A B C D

Il y a une nuance ici. L'itérateur est revenu à la fin () pointe vers l'élément, qui aurait dû être là, s'il n'avait pas été supprimé.

Suppression avec POP_BACK

La fonction membre pop_back () supprime le dernier élément du vecteur, par définition. Le programmeur n'a donc pas besoin d'identifier le dernier élément. Sa syntaxe est

un.pop_back ()

où «a» est le nom du vecteur. Cela ne prend aucun argument; il revient vide. Le programme suivant supprime le dernier élément d'un vecteur:

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

vector vtr = 'a', 'b', 'c', 'd', 'e';
vtr.pop_back ();
pour (int i = 0; i < vtr.size(); i++)
couter << vtr[i] << ";
couter << endl;
pour (vector :: iterator it = vtr.commencer(); il != VTR.fin(); it ++)
couter << *it << ";
couter << endl;
retour 0;

La sortie est:

A B C D
A B C D

Conclusion

Le vecteur C ++ a de nombreuses fonctions membres. Deux de ces fonctions membres sont effacées () et pop_back (). pop_back () supprime le dernier élément du vecteur. Afin de supprimer tous les éléments du vecteur, en utilisant pop_back (), la fonction pop_back () doit être répétée le nombre de fois où il y a des éléments. La fonction effacer () peut supprimer un élément du début, à l'intérieur ou à la fin du vecteur. Afin de supprimer tous les éléments du vecteur, en utilisant effacer (), la fonction effacer () doit être répétée le nombre de fois où il y a des éléments, à partir du premier élément.

Afin de supprimer un élément spécifique du vecteur C ++, l'élément doit être identifié. Pour la fonction de membre effacer (), l'élément est identifié par un itérateur. Puisque la fonction membre POP_BACK () supprime le dernier élément par définition, l'élément spécifique qu'il doit supprimer a déjà été identifié indirectement.