Fonctions des membres vectoriels C ++ les plus utiles

Les fonctions des membres du vecteur C ++ peuvent être placées dans les catégories suivantes: construction, capacité, itérateurs, accès aux éléments et modificateurs. Chacune de ces catégories a de nombreuses fonctions. Toutes ces fonctions ne sont pas utilisées dans de nombreuses applications. Cet article explique le plus utile de ces fonctions. À l'exception de la catégorie des modificateurs, pas plus de trois fonctions pour chaque catégorie sont expliquées dans cet article. La catégorie des modificateurs peut être divisée en plus de sous-catégories. Dans chacune de ces sous-catégories, pas plus de trois fonctions seront expliquées. Si plus de trois fonctions doivent être expliquées pour une catégorie donnée, alors ils seront enseignés par voie d'illustration.

Un programme pour utiliser le vecteur C ++ devrait commencer,

#inclure
#inclure

Contenu de l'article

• Construction / destruction
• Capacité
• Accès itérateur et vecteur
• Accès à l'élément
• Repousser et revenir en arrière
• Insertion
• Attribution d'éléments (remplacements)
• Effacer
• Clair
• Échange
• Conclusion

Construction / destruction

Les segments de code suivants montrent différentes façons de créer le même vecteur:

vecteur Vtr;
vtr.push_back (5.5);
vtr.push_back (6.6);
vtr.push_back (7.7);
vtr.push_back (8.8);
vtr.push_back (9.9);
vecteur vtr (3); // avec un nombre initial d'éléments
vtr [0] = 5.5;
vtr [1] = 6.6;
vtr [2] = 7.7;
vecteur vtr (5, 0.0); //Non. Éléments: 5; Chaque valeur: 0.0
vecteur vtr 5.5, 6.6, 7.7, 8.8, 9.9; // initialisation
vecteur vtr = 5.5, 6.6, 7.7, 8.8, 9.9; // Construction et copie
vecteur Vtr;
vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
vecteur vtr1 5.5, 6.6, 7.7, 8.8, 9.9;
vecteur vtr2 (vtr1);
vctor de constance vtr = 5.5, 6.6, 7.7, 8.8, 9.9;

UN vctor de constance est un vecteur dont les éléments ne peuvent pas être modifiés. Les valeurs sont en lecture seule.

Destruction

Pour détruire un vecteur, laissez-le sortir de la portée.

Capacité

size () const noexcept

Le nombre d'éléments dans un vecteur est renvoyé par cette fonction membre. Avec le segment de code suivant, la sortie est de 5:

vecteur vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
float sz = vtr.taille();
couter << sz << '\n';
vide () const noexcept

Cette méthode renvoie True (1) si le vecteur n'a pas d'élément et faux (0) si le vecteur a au moins un élément. Avec le code suivant, la sortie est 1 (pour true):

vecteur vtr = ;
bool bl = vtr.vide();
couter << bl << '\n';

Accès itérateur et vecteur

Un itérateur est un pointeur élaboré. Quand le vecteur, vtr a été créé, vtr.commencer() retournerait un itérateur, pointant vers le premier élément de la liste. Il peut ensuite être incrémenté pour accéder aux éléments après le premier, en conséquence.

Quand le vecteur, vtr a été créé, vtr.fin() retournerait un itérateur, pointant juste après le dernier élément de la liste. Il peut alors être décrémenté pour accéder au dernier élément et aux éléments avant le dernier, en conséquence. Le programme suivant illustre ceci:

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

vecteur vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
vecteur:: iterator iterb = vtr.commencer();
iterb ++;
vecteur:: iterator itere = vtr.fin();
itere--;
couter << *iterB << ", " << *iterE << " << endl;
* iterb = 66.66; * itere = 99.99;
couter << *iterB << ", " << *iterE << " << endl;
retour 0;

La sortie est:

6.6, 9.9
66.66, 99.99

Les valeurs de deux éléments ont été accessibles, lues et modifiées par deux itérateurs.

Accès à l'élément

à (i)

C'est similaire à Vtr [i], et c'est mieux. Il peut être utilisé pour lire ou modifier la valeur d'un élément. Le comptage d'index commence à partir de zéro. Le lecteur peut tester le programme suivant:

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

vecteur vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
couter << vtr[1] << ", " << vtr[4] << " << endl;
vtr [1] = 66.66; vtr [4] = 99.99;
couter << vtr[1] << ", " << vtr[4] << " << endl;
retour 0;

La sortie est:

6.6, 9.9
66.66, 99.99

Les valeurs de deux éléments ont été accessibles, lues et modifiées en référençant.

Renvoi de la première valeur

Le code suivant renvoie (copie) le premier élément:

vecteur vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
Float Val = Vtr.devant();
couter << val << endl;

La sortie est, 5.5. La fonction membre utilisée ici est: Front ().

Renvoi de la dernière valeur

Le code suivant renvoie (copie) le dernier élément:

vecteur vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
Float Val = Vtr.dos();
couter << val << endl;

La sortie est, 9.9. La fonction membre utilisée ici est: back ().

Repousser et revenir en arrière

repousser()

Un élément peut être ajouté à l'arrière du vecteur. La valeur peut être littérale ou être représentée par l'identifiant. Le code suivant illustre ceci:

float flt = 10.dix;
vecteur vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
vtr.push_back (flt);
pour (int i = 0; icouter << vtr[i] << ", ";
couter << endl;

La liste originale est:

5.5, 6.6, 7.7, 8.8, 9.9

La nouvelle liste est:

5.5, 6.6, 7.7, 8.8, 9.9, 10.1

pop_back ()

Le dernier élément peut être supprimé du vecteur. Le code suivant illustre ceci:

vecteur vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
vtr.pop_back ();
pour (int i = 0; icouter << vtr[i] << ", ";
couter << endl;

La liste originale est:

5.5, 6.6, 7.7, 8.8, 9.9

La nouvelle liste est:

5.5, 6.6, 7.7, 8.8

Note: Le vecteur n'a pas les fonctions de membre push_front () et pop_front ().

Insertion

Les inserts devant l'élément pointé, par l'itérateur.

insérer (p, e)

Cela insère un élément devant l'élément pointé par l'itérateur, P. E peut être un littéral ou un identifiant. Illustration:

float flt = 7.0;
vecteur vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
vecteur:: iterator iterb = vtr.commencer();
iterb ++; iterb ++;
vtr.insérer (iterb, flt);
pour (int i = 0; icouter << vtr[i] << ", ";
couter << endl;

La liste originale est:

5.5, 6.6, 7.7, 8.8, 9.9

La nouvelle liste est:

5.5, 6.6, 7, 7.7, 8.8, 9.9

Cette fonction d'insert renvoie un itérateur (non codé) qui pointe vers l'élément inséré.

insert (p, il)

Une liste peut être insérée devant l'élément pointé par l'itérateur. Illustration:

vecteur vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
vecteur:: iterator iterb = vtr.commencer();
iterb = iterb + 2;
vtr.insérer (iterb, 7.1, 7.2, 7.3);
pour (int i = 0; icouter << vtr[i] << ", ";
couter << endl;

La liste originale est:

5.5, 6.6, 7.7, 8.8, 9.9

La nouvelle liste est:

5.5, 6.6, 7.1, 7.2, 7.3, 7.7, 8.8, 9.9

Cette fonction d'insert renvoie un itérateur (non codé) qui pointe vers le premier élément inséré.

insert (p, n, t)

Insère la même valeur t, n fois, devant l'élément pointé par P. Illustration:

vecteur vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
vecteur:: iterator iterb = vtr.commencer();
iterb = iterb + 2;
vtr.insérer (iterb, 3, 7.1);
pour (int i = 0; icouter << vtr[i] << ", ";
couter << endl;

La liste originale est:

5.5, 6.6, 7.7, 8.8, 9.9

La nouvelle liste est:

5.5, 6.6, 7.1, 7.1, 7.1, 7.7, 8.8, 9.9

Cette fonction d'insert renvoie un itérateur (non codé) qui pointe vers le premier élément inséré.

insérer (p, i, j)

Une gamme peut être copiée à partir d'un autre vecteur et insérée dans le vecteur d'intérêt. Le code suivant illustre ceci:

vecteur vtr1 = 7.1, 7.2, 7.3, 7.4, 7.5;
vecteur:: iterator iterb1 = vtr1.commencer();
iterb1 = iterb1 + 1;
vecteur:: iterator itere1 = vtr1.fin();
itere1 = itere1 - 2;
vecteur vtr2 = 5.5, 6.6, 7.7, 8.8, 9.9;
vecteur:: iterator iterb2 = vtr2.commencer();
iterb2 = iterb2 + 2;
vtr2.insert (iterb2, iterb1, iterere1);
pour (int i = 0; icouter << vtr2[i] << ", ";
couter << endl;

La liste originale de Vtr2 est:

5.5, 6.6, 7.7, 8.8, 9.9

La nouvelle liste de VTR2 est:

5.5, 6.6, 7.2, 7.3, 7.7, 8.8, 9.9

La gamme identifiée à copier est [7.2, 7.3, 7.4), indiqué comme [i, j), signifiant la dernière valeur, 7.4 n'est pas inclus.

Cette fonction d'insert renvoie un itérateur (non codé) qui pointe vers le premier élément inséré.

Attribution d'éléments (remplacements)

Attribuer aux éléments signifie remplacer les éléments par des copies. Toutes les fonctions des membres de l'affectation, retour void.

attribuer (IL)

Une liste peut remplacer tous les éléments du vecteur en question. La liste peut être plus longue ou plus courte. Illustration pour la liste courte:

vecteur vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
vecteur:: iterator iterb = vtr.commencer();
iterb = iterb + 2;
vtr.attribuer (55.55, 66.66, 77.77);
pour (int i = 0; icouter << vtr[i] << ", ";
couter << endl;

La liste originale est:

5.5, 6.6, 7.7, 8.8, 9.9

La nouvelle liste est:

55.55, 66.66, 77.77

Illustration pour la liste plus longue:

vecteur vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
vecteur:: iterator iterb = vtr.commencer();
iterb = iterb + 2;
vtr.attribuer (55.55, 66.66, 77.77, 88.88, 99.99, 1010.1111);
pour (int i = 0; icouter << vtr[i] << ", ";
couter << endl;

La liste originale est:

5.5, 6.6, 7.7, 8.8, 9.9

La nouvelle liste est:

55.55, 66.66, 77.77, 88.88, 99.99, 1010.11

attribuer (n, t)

La même valeur, répétée plusieurs fois, peut remplacer tous les éléments du vecteur en question. La nouvelle liste peut être plus longue ou plus courte. Illustration pour la liste courte:

vecteur vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
vecteur:: iterator iterb = vtr.commencer();
iterb = iterb + 2;
vtr.Assign (2, 77.77);
pour (int i = 0; icouter << vtr[i] << ", ";
couter << endl;

La liste originale est:

5.5, 6.6, 7.7, 8.8, 9.9

La nouvelle liste est:

77.77, 77.77

Assign (i, j)

Une gamme peut être copiée à partir d'un autre vecteur et être utilisée pour remplacer tout le contenu du vecteur d'intérêt. Le code suivant illustre ceci:

vecteur vtr1 = 7.1, 7.2, 7.3, 7.4, 7.5;
vecteur:: iterator iterb1 = vtr1.commencer();
iterb1 = iterb1 + 1;
vecteur:: iterator itere1 = vtr1.fin();
itere1 = itere1 - 2;
vecteur vtr2 = 5.5, 6.6, 7.7, 8.8, 9.9;
vecteur:: iterator iterb2 = vtr2.commencer();
iterb2 = iterb2 + 2;
vtr2.attribuer (iterb1, itere1);
pour (int i = 0; icouter << vtr2[i] << ", ";
couter << endl;

La liste originale de Vtr2 est:

5.5, 6.6, 7.7, 8.8, 9.9

La nouvelle liste de VTR2 est:

7.2, 7.3

La gamme identifiée à copier est [7.2, 7.3, 7.4), indiqué comme [i, j), signifiant la dernière valeur, 7.4 n'est pas inclus.

Effacer

Utilise iterator.

Effacer (Q)

Supprime l'élément pointé par Q, raccourcissant la longueur du vecteur. Renvoie l'itérateur pointant vers l'élément suivant, après le retrait. Exemple:

vecteur vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
vecteur:: iterator iterb = vtr.commencer();
iterb = iterb + 2;
vecteur:: iterator itr = vtr.effacer (iterb);
pour (int i = 0; icouter << vtr[i] << ", ";
couter << endl;
couter << *itR << endl;

La liste originale est:

5.5, 6.6, 7.7, 8.8, 9.9

La sortie est:

5.5, 6.6, 8.8, 9.9,
8.8

Effacer (Q1, Q2)

Supprime une gamme d'éléments commençant par celle indiquée par l'itérateur Q1, à celle indiquée par Q2, mais à l'exclusion de celui de Q2 - c'est-à-dire qu'il supprime [Q1, Q2). Renvoie l'itérateur pointant vers l'élément suivant, après la suppression de la plage. Illustration:

vecteur vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
vecteur:: iterator iterb = vtr.commencer();
iterb = iterb + 2;
vecteur:: iterator itere = vtr.fin();
itere = itere - 1;
vecteur:: iterator itr = vtr.Effacer (iterb, itere);
pour (int i = 0; icouter << vtr[i] << ", ";
couter << endl;
couter << *itR << endl;

La liste originale est:

5.5, 6.6, 7.7, 8.8, 9.9

La sortie est:

5.5, 6.6, 9.9,
9.9

Clair

clair()

Revient vide. Tous les éléments d'un vecteur peuvent être retirés, réduisant la longueur du vecteur à zéro. C'est ainsi:

vecteur vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
vtr.clair();
couter << vtr.size() << endl;

La liste originale est:

5.5, 6.6, 7.7, 8.8, 9.9

La sortie est:

0

Échange

X.échange (y)

Les éléments de deux vecteurs différents peuvent être échangés, indépendamment de leurs différentes longueurs. Illustration:

vecteur vtr1 = 1.1, 2.2, 3.3, 4.4;
vecteur vtr2 = 5.5, 6.6, 7.7, 8.8, 9.9;
vtr2.échange (vtr1);
couter << "New vtr1: ";
pour (int i = 0; icouter << vtr1[i] << ", ";
couter << endl;
couter << "New vtr2: ";
pour (int i = 0; icouter << vtr2[i] << ", ";
couter << endl;

La sortie est:

Nouveau Vtr1: 5.5, 6.6, 7.7, 8.8, 9.9,
Nouveau Vtr2: 1.1, 2.2, 3.3, 4.4,

Conclusion

Le vecteur C ++ a de nombreuses fonctions membres. Ces fonctions peuvent être classées dans les sous-catégories suivantes: construction / destruction, capacité, accès itérateur et vecteur, accès aux éléments, repousser et revenir, insérer, attribuer des éléments (remplacements), effacer, effacer et échanger. Les fonctions les plus utiles de chacune de ces sous-catégories ont été expliquées ci-dessus.