V ++ vecteur clair vs effacer

Le vecteur C ++ a de nombreuses fonctions membres. Deux d'entre eux sont clear () et effacer (). clair() «Supprime» tous les éléments du vecteur. effacer () «supprime» un seul élément ou une gamme d'éléments. Il existe deux variantes surchargées de la fonction de membre effacer () pour le vecteur.

Le titre de cet article est en fait "la fonction de membre Vector Clear () contre Vector Erase () Member Fonction, en C ++". Ceci est une comparaison des fonctions de deux membres. Il traite quand utiliser lequel, comment utiliser lesquels, et dans quelles conditions sont utilisées.

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

#inclure
#inclure
Utilisation de Namespace Std;

Contenu de l'article

• Vector Clear ()
• Vector effacer
• Pop_back
• Détruire un vecteur
• Conclusion

Vector Clear ()

La fonction du membre Clear () «supprime» tous les éléments du vecteur. Sa syntaxe est:

void clear ()

Il revient vide. Le programme suivant illustre son utilisation, avec l'expression: «Vtr.clair();":

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

vecteur vtr = 'p', 'q', 'r', 's', 't', 'u';
pour (vecteur:: iterator it = vtr.commencer(); il != VTR.fin(); it ++)
couter << *it << ";
couter << endl;
vtr.clair();
pour (vecteur:: iterator it = vtr.commencer(); il != VTR.fin(); it ++)
couter << *it << ";
couter << endl;
retour 0;

La sortie est la seule ligne:

P q r s t u

Si le vecteur n'avait pas été effacé, la sortie aurait été deux lignes de la même séquence. Aucune deuxième ligne n'a été affichée car tous les éléments ont été effacés.

const Vector et Clear ()

Lorsqu'une déclaration de vecteur est précédée par const, cela signifie que les éléments du vecteur ne peuvent pas être supprimés ou modifiés. Si une expression tente de changer ou de supprimer l'un des éléments, le programme ne compile pas. Testez le programme suivant et notez qu'il ne compile pas:

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

vctor de constance vtr = 'p', 'q', 'r', 's', 't', 'u';
pour (vecteur:: const_iterator it = vtr.commencer(); il != VTR.fin(); it ++)
couter << *it << ";
couter << endl;
vtr.clair();
pour (vecteur:: const_iterator it = vtr.commencer(); il != VTR.fin(); it ++)
couter << *it << ";
couter << endl;
retour 0;

Si le programme était testé, un message d'erreur aurait été émis et il n'y aurait eu aucune compilation. Parce que le vecteur a été déclaré constant, la fonction claire () ne pouvait pas fonctionner, résultant en un message d'erreur du compilateur.

Note: clear () supprime tous les éléments du vecteur. En fait, il a des écouteurs tous les éléments tels que supprimés, de sorte que d'autres codes peuvent prendre leur emplacement de mémoire. Si l'emplacement de la mémoire d'un élément n'a pas encore été repris par un autre code, alors l'élément peut toujours être réutilisé au nom du même vecteur.

Vector effacer

Les syntaxes simplifiées pour les deux fonctions des membres effacer () sont:

un.Effacer (Q)
et
un.Effacer (Q1, Q2)

où a est le nom du vecteur.

Iterator Erase (const_iterator position)

Ceci est la syntaxe complète pour «A.effacer (q) ». Il renvoie un itérateur pointant vers l'élément, qui était juste derrière celui effacé. L'argument, Q est un itérateur pointant vers l'élément à effacer. Le programme suivant illustre ceci:

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

vecteur vtr = 'p', 'q', 'r', 's', 't', 'u';
vecteur:: iterator iter = vtr.commencer();
++iter; ++ iter;
vecteur:: iterator it = vtr.effacer (iter);
pour (int i = 0; i < vtr.size(); i++)
couter << vtr[i] << ";

couter << endl;
couter << *it << endl;
retour 0;

La sortie est:

P q s t u
S

'R' a été supprimé. L'itérateur retourné pointe désormais vers «s», qui était juste après «R». La fonction membre, begin (), renvoie un itérateur qui pointe vers le premier élément du vecteur. Dans le code, cet itérateur a été incrémenté deux fois pour pointer vers «R». 'R' a été effacé avec l'expression: «Vtr.effacer (iter) ».

Plage de vecteur

Pour la liste,

'P', 'Q', 'R', 'S', 'T', 'U'

La séquence, «q», «r», «s», «t» est une gamme. Cependant, avec les conteneurs C ++, le dernier élément, «t» n'est pas considéré comme faisant partie de la gamme. Ceci est indiqué en termes généraux comme:

[I, J)
ou
[Q1, Q2)

'[' Dans ce cas, signifie que le premier élément de la séquence est inclus, et ')' signifie que le dernier élément n'est pas inclus.

Iterator effacer (const_iterator d'abord, const_iterator dernier)

Ceci est la syntaxe complète pour «A.Effacer (Q1, Q2) ». Il renvoie un itérateur pointant vers l'élément, qui était juste derrière la gamme effacée. Remarque: le dernier élément de la plage n'est pas effacé. Ainsi, l'itérateur retourné pointera vers le dernier élément de la plage. Les arguments Q1 et Q2 sont des itérateurs pointant vers les premier et derniers éléments de la gamme. Le programme suivant illustre ceci:

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

vecteur vtr = 'p', 'q', 'r', 's', 't', 'u';
vecteur:: iterator itb = vtr.commencer();
++ITB;
vecteur:: iterator ite = vtr.fin();
--ite; --ite;
vecteur:: iterator it = vtr.effacer (itb, ite);
pour (int i = 0; i < vtr.size(); i++)
couter << vtr[i] << ";

couter << endl;
couter << *it << endl;
retour 0;

La sortie est:

P t u
T

'Q', 'r', 's' ont été supprimés. L'itérateur retourné pointe désormais vers «t», qui était le dernier élément de la plage de conteneurs. La fonction membre, end (), renvoie un itérateur qui pointe juste après le dernier élément du vecteur. Dans le code, cet itérateur a été décrémenté deux fois pour pointer vers «t», le dernier élément de la plage. «Q», «R», «S» ont été supprimés sans le dernier élément, «t» dans la gamme, avec l'expression: «Vtr.effacer (itb, ite) ».

Const Vector et Erase ()

Si la déclaration d'un vecteur est précédée de const, pour constante, alors aucun de ses éléments ne peut être effacé. Le programme suivant ne se compilera pas, émettant un message d'erreur pour le A.Effacer (q) Expression:

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

vctor de constance vtr = 'p', 'q', 'r', 's', 't', 'u';
vecteur:: const_iterator iter = vtr.commencer();
++iter; ++ iter;
vecteur:: const_iterator it = vtr.effacer (iter);
pour (int i = 0; i < vtr.size(); i++)
couter << vtr[i] << ";

couter << endl;
couter << *it << endl;
retour 0;

Si le lecteur essayait le programme, il aurait reçu un message d'erreur. Le programme n'aurait pas compilé.

Le programme suivant ne se compilera pas, émettant un message d'erreur pour le A.Effacer (Q1, Q2) Expression:

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

vctor de constance vtr = 'p', 'q', 'r', 's', 't', 'u';
vecteur:: const_iterator itb = vtr.commencer();
++ITB;
vecteur:: const_iterator ite = vtr.fin();
--ite; --ite;
vecteur:: const_iterator it = vtr.effacer (itb, ite);
pour (int i = 0; i < vtr.size(); i++)
couter << vtr[i] << ";

couter << endl;
couter << *it << endl;
retour 0;

Remarque: eff effrayer () supprime un élément ou une gamme d'éléments. En fait, il a fait un élément comme supprimé, de sorte que leurs emplacements de mémoire peuvent être absorbés par d'autres codes. Si l'emplacement de la mémoire d'un élément n'a pas encore été repris par un autre code, alors l'élément peut toujours être réutilisé au nom du même vecteur.

pop_back ()

La fonction du membre du vecteur pop_back () est une sorte de fonction effacer (). Cependant, il ne supprime que le dernier élément du vecteur. La syntaxe est:

void pop_back ()

Il ne prend aucun argument et revient vide. Le programme suivant illustre son utilisation:

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

vecteur vtr = 'p', 'q', 'r', 's', 't', 'u';
vtr.pop_back ();
pour (int i = 0; i < vtr.size(); i++)
couter << vtr[i] << ";

couter << endl;
retour 0;

La sortie est:

P q r s t

Le dernier élément, «u» a été supprimé (effacé).

Détruire un vecteur

Un vecteur peut-il être détruit? - Oui! Cependant, lorsqu'un vecteur est détruit, tous ses éléments sont effacés sauf son nom; ce qui signifie que la déclaration vectorielle peut encore être réutilisée, mais avec une certaine incertitude. La syntaxe pour détruire un vecteur est:

un.~ X ()

où «a» est le nom du vecteur. Le programme suivant illustre ceci:

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

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

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

couter << endl;
retour 0;

La sortie est:

V w x y z
p ^ t e @ a c d e

de l'ordinateur de l'auteur, avec quelques caractères peu fiables pour la deuxième ligne.

Conclusion

La fonction du membre vectoriel ne peut être comparée à la fonction du membre vectoriel effacer (). Ce ne sont pas des substituts. clear () supprime tous les éléments du vecteur. En fait, il a des écouteurs tous les éléments tels que supprimés, de sorte que leurs emplacements de mémoire peuvent être repris par d'autres codes. Si l'emplacement de la mémoire d'un élément n'a pas encore été repris par un autre code, alors l'élément peut toujours être réutilisé au nom du même vecteur. effacer () supprime un élément ou une gamme d'éléments. En fait, il a fait un élément comme supprimé, de sorte que l'emplacement de la mémoire peut être absorbé par un autre code. Si l'emplacement de la mémoire d'un élément supprimé n'a pas encore été repris par un autre code, l'élément peut toujours être réutilisé au nom du même vecteur. Clear a une similitude pour détruire, ~ x ().