Comment utiliser le vecteur C++

introduction

Un tableau est une série de mêmes types d'objets dans des emplacements mémoire consécutifs. Un tableau ne peut pas augmenter le minerai réduire en longueur. Un vecteur est comme un tableau, mais sa longueur peut être augmentée ou réduite. Un vecteur a donc beaucoup plus d'opérations qu'un tableau.

C++ a de nombreuses bibliothèques, qui forment toutes la bibliothèque standard C++. L'une de ces bibliothèques est la bibliothèque de conteneurs. Un conteneur est une collection d'objets, et certaines opérations peuvent être effectuées sur la collection. Les conteneurs C++ peuvent être regroupés en deux ensembles : les conteneurs de séquence et les conteneurs associatifs. Les conteneurs de séquence sont vector, array (pas le même tableau discuté précédemment), deque, forward_list et list. Ce sont des collections différentes (structures de données de type tableau), et chacune offre des compromis distincts.

Tout programmeur doit savoir comment décider d'utiliser un vecteur, un tableau, un deque, une forward_list ou une liste. Lorsqu'un programmeur a besoin d'une structure qui nécessite plus d'opérations que celles associées à un tableau ordinaire, le tableau ordinaire ne doit pas être utilisé.

Si la tâche implique des insertions et des suppressions fréquentes au milieu de la séquence, alors une liste ou une forward_list doit être utilisée. Si la tâche implique des insertions et des suppressions fréquentes au début ou à la fin d'une séquence, alors un deque doit être utilisé. Un vecteur doit être utilisé lorsque ces types d'opérations ne sont pas nécessaires.

Cet article vous montre comment utiliser le vecteur C++. Vous aurez besoin d'une certaine connaissance des pointeurs, des références et des tableaux C++ pour comprendre cet article.

Classe et objets

Une classe est un ensemble de variables et de fonctions qui fonctionnent ensemble, où les variables n'ont pas de valeurs affectées. Lorsque des valeurs sont affectées aux variables, une classe devient un objet. Des valeurs différentes attribuées à la même classe donnent des objets différents ; c'est-à-dire que différents objets peuvent être de la même classe mais avoir des valeurs différentes. La création d'un objet à partir d'une classe est également appelée instanciation de l'objet.

Le terme vecteur décrit une classe. Un objet créé à partir d'un vecteur a un nom qui est choisi par le programmeur.

Une fonction qui appartient à une classe est nécessaire pour instancier un objet de la classe. En C++, cette fonction a le même nom que le nom de la classe. Différents objets créés (instanciés) à partir de la classe ont des noms distincts donnés à chacun d'eux par le programmeur.

Créer un objet à partir d'une classe signifie construire l'objet ; cela signifie aussi instancier l'objet.

La classe vectorielle

La classe vectorielle a déjà été définie et se trouve dans la bibliothèque. Pour utiliser la classe vectorielle, un programmeur doit inclure l'en-tête vectoriel dans le fichier avec la directive de prétraitement suivante :

#inclure

Une fois l'en-tête inclus, toutes les fonctionnalités vectorielles (membres de données et fonctions membres) deviennent accessibles. Pour utiliser l'objet de comptage pour envoyer des données au terminal (console), l'en-tête de l'objet doit également être inclus. Pour écrire un programme avec le vecteur, au minimum, les en-têtes suivants doivent être inclus :

#inclure
#inclure

Instanciation d'un vecteur

int foo [10];

Ci-dessus se trouve la déclaration d'un tableau avec le nom "foo" et le nombre d'éléments "10.” Ceci est un tableau d'entiers. La déclaration d'un vecteur est similaire. Pour un vecteur, le nombre d'éléments est facultatif, car la longueur du vecteur peut augmenter ou diminuer.

À ce stade du programme, la classe vectorielle a déjà été définie dans la bibliothèque et l'en-tête a été inclus. Le vecteur peut être instancié comme suit :

std::vecteur vtr (8);

Ici, le vecteur est de la fonction constructeur spéciale. Le type de données que le vecteur contiendra est « int », entre crochets angulaires. Le terme « vtr » est le nom choisi par le programmeur pour le vecteur. Enfin, "8", entre parenthèses, est le nombre provisoire d'entiers que le vecteur aura.

Le terme "std" signifie espace de noms standard. Ce terme doit être suivi d'un double deux-points, dans ce contexte. Tout le monde peut écrire sa propre bibliothèque de classes vectorielles et l'utiliser. Cependant, C++ a déjà une bibliothèque standard avec des noms standard, y compris "vector.” Pour utiliser un nom standard, le nom standard doit être précédé de std :: . Pour éviter de taper std :: à chaque fois dans le programme pour un nom standard, le fichier programme peut démarrer comme suit :

#inclure
#inclure
en utilisant l'espace de noms std ;

Surcharger une fonction

Lorsque deux ou plusieurs signatures de fonction différentes ont le même nom, ce nom est dit surchargé. Lorsqu'une fonction est appelée, le nombre et le type d'arguments déterminent quelle fonction est exécutée.

Construire un vecteur

Construire un vecteur signifie instancier (créer) un objet vectoriel. La fonction constructeur est surchargée comme suit :

vecteur Nom

Cela crée un vecteur de longueur zéro et tapez "T." L'instruction suivante crée un vecteur de longueur nulle du type " float " avec le nom " vtr : "

vecteur vtr;

vecteur nom (n)

Cela crée un vecteur avec n éléments de type "T.” Une déclaration pour ce vecteur avec quatre éléments flottants est la suivante :

vecteur vtr(4);

vecteur nom (n, t)

Cela crée un vecteur de n éléments initialisé à la valeur t. L'instruction suivante crée un vecteur de 5 éléments, où chaque élément a la valeur 3.4:

vecteur magnétoscope (5, 3.4);

Construction avec initialisation

Un vecteur peut être construit (créé) et initialisé en même temps, de l'une des deux manières suivantes :

vecteur vtr = 1.1, 2.2, 3.3, 4.4 ;

Ou alors

vecteur vtr1.1, 2.2, 3.3, 4.4 ;

Notez qu'il n'y a pas de parenthèses juste après le nom de l'objet. Les parenthèses utilisées juste après le nom de l'objet doivent avoir la liste d'initialisation, comme suit :

vecteur vtr(1.1, 2.2, 3.3, 4.4);

Un vecteur peut être construit et initialisé plus tard avec la liste d'initialisation. Dans ce cas, les parenthèses ne seront pas utilisées :

vecteur vtr;
vtr = 1.1, 2.2, 3.3, 4.4 ;

vecteur V2 (V1)

Ceci est un constructeur de copie. Il crée un vecteur V2 comme une copie du vecteur V1. Le code suivant illustre cela :

vecteur vtr1(5, 3.4);
vecteur vtr2(vtr1) ;

Attribution d'un vecteur pendant la construction

Lors de la construction, un vecteur vide peut être créé tandis qu'un autre lui est affecté, comme suit :

vecteur vtr11.1, 2.2, 3.3, 4.4 ;
vecteur vtr2 =vtr1;

La deuxième déclaration équivaut à :

vecteur vtr2 = 1.1, 2.2, 3.3, 4.4 ;

const Vectoriel

Un vecteur const est un vecteur dont les éléments ne peuvent pas être modifiés. Les valeurs de ce vecteur sont en lecture seule. Une fois créé, le vecteur apparaît comme suit :

vecteur const vtr1.1, 2.2, 3.3, 4.4 ;

Dans ce type de vecteur, aucun élément ne peut être ajouté ou supprimé. De plus, aucune valeur ne peut être modifiée.

Construire avec Iterator

Un modèle fournit une représentation générique pour un type de données. Un itérateur fournit une représentation générique du balayage à travers les valeurs d'un conteneur. La syntaxe pour créer un vecteur avec un itérateur est la suivante :

modèle
vector(InputIterator en premier, InputIterator en dernier,const Allocator& = Allocator());

Cela construit un vecteur pour la plage [premier, dernier) en utilisant l'allocateur spécifié, qui sera discuté plus loin dans cet article.

Détruire un vecteur

Pour détruire un vecteur, laissez-le simplement sortir de la portée et la destruction est gérée automatiquement.

Capacité vectorielle

size_type capacité() const noexcept

Le nombre total d'éléments que le vecteur peut contenir sans nécessiter de réallocation est renvoyé par la fonction membre de capacité. Un segment de code pour cela est le suivant :

vecteur vtr(4);
int num = vtr.capacité();
cout << num << '\n';

La sortie est de 4.

réserve(n)

L'espace mémoire n'est pas toujours disponible gratuitement. Un espace supplémentaire peut être réservé à l'avance. Considérez le segment de code suivant :

vecteur vtr(4);
magnétoscope.réserve(6) ;
cout << vtr.capacity() << '\n';

La sortie est 6. Ainsi, l'espace supplémentaire réservé est de 6 - 4 = 2 éléments. La fonction renvoie void.

size() const noexcept

Cela renvoie le nombre d'éléments dans le vecteur. Le code suivant illustre cette fonction :

vecteur vtr(4);
flotteur sz = vtr.Taille();
cout << sz << '\n';

La sortie est de 4.

rétrécir_pour_adapter()

Après avoir donné une capacité supplémentaire à un vecteur avec la fonction reserve(), le vecteur peut être redimensionné pour s'adapter à sa taille d'origine. Le code suivant illustre cela :

vecteur vtr(4);
magnétoscope.réserve(6) ;
magnétoscope.rétrécir_pour_adapter();
int sz = vtr.Taille();
cout << sz << '\n';

La sortie est 4 et non 6. La fonction renvoie void.

redimensionner(sz), redimensionner(sz,c)

Cela redimensionne le vecteur. Si la nouvelle taille est plus petite que l'ancienne taille, alors les éléments vers la fin sont effacés. Si la nouvelle taille est plus longue, une valeur par défaut est ajoutée vers la fin. Pour avoir une valeur ajoutée particulière, utilisez la fonction resize() avec deux arguments. Le segment de code suivant illustre l'utilisation de ces deux fonctions :

vecteur vtr11.1, 2.2, 3.3, 4.4 ;
vtr1.redimensionner(2);
cout << "New size of vtr1: " << vtr1.size() << '\n';
vecteur vtr21.1, 2.2 ;
vtr2.redimensionner (4, 8.8);
cout << "vtr2: "<< vtr2[0] <<" "<< vtr2[1] <<"
"<< vtr2[2] <<" "<< vtr2[3] << '\n';

La sortie est la suivante :

Nouvelle taille de vtr1 : 2
vtr2 : 1.1 2.2 8.8 8.8

Les fonctions retournent void.

empty() const noexcept

Cette fonction renvoie 1 pour vrai s'il n'y a pas d'éléments dans le vecteur et 0 pour faux si le vecteur est vide. Si un vecteur a 4 emplacements pour un type particulier de données, tel que float, sans aucune valeur float, alors ce vecteur n'est pas vide. Le code suivant illustre cela :

vecteur vtr;
cout << vtr.empty() << '\n';
vecteur vt(4);
cout << vt.empty() << '\n';
vecteur v(4,3.5);
cout << v.empty() << '\n';

La sortie est la suivante :

1
0
0

Accès aux éléments vectoriels

Un vecteur peut être sous-scripté (indexé) comme un tableau. Le comptage d'index commence à partir de zéro.

nom du vecteur[i]

L'opération « vectorName[i] » renvoie une référence à l'élément au i^e indice du vecteur. Le code suivant renvoie 3.3 pour le vecteur ci-dessus :

vecteur vtr1.1, 2.2, 3.3, 4.4 ;
float fl = vtr[2];
cout << fl << '\n';

vectorName[i] const

L'opération « vectorName[i] const » est exécutée à la place de « vectorName[i] » lorsque le vecteur est un vecteur constant. Cette opération est utilisée dans le code suivant :

vecteur const vtr1.1, 2.2, 3.3, 4.4 ;
float fl = vtr[2];
cout << fl << '\n';

L'expression renvoie une référence constante au i^e élément du vecteur.

Affectation d'une valeur avec indice

Une valeur peut être affectée à un vecteur non constant, comme suit :

vecteur vtr1.1, 2.2, 3.3, 4.4 ;
vtr[2] = 8.8 ;
cout << vtr[2] << '\n';

La sortie est 8.8.

nom du vecteur.à (i)

"Nom du vecteur.at(i)" est comme "vectorName[i]", mais "vectorName.at(i)" est plus fiable. Le code suivant montre comment ce vecteur doit être utilisé :

vecteur vtr1.1, 2.2, 3.3, 4.4 ;
float fl = vtr.à 2 heures);
cout << fl << '\n';
at() est une fonction membre vectorielle.

nom du vecteur.à(i) const

"Nom du vecteur.at(i) const" est comme "vectorName[i] const", mais "vectorName.at(i) const" est plus fiable. "Nom du vecteur.at(i) const" est exécuté au lieu de "vectorName.at(i)” lorsque le vecteur est un vecteur constant. Ce vecteur est utilisé dans le code suivant :

vecteur const vtr1.1, 2.2, 3.3, 4.4 ;
float fl = vtr.à 2 heures);
cout << fl << '\n';
at() const est une fonction membre vectorielle.

Attribuer une valeur avec la fonction at()

Une valeur peut être affectée à un vecteur non constant avec la fonction at(), comme suit :

vecteur vtr1.1, 2.2, 3.3, 4.4 ;
magnétoscope.à(2) = 8.8 ;
cout << vtr[2] << '\n';

La sortie est 8.8.

Problème de sous-script

Le problème avec les sous-scripts (indexation) est que si l'index est hors plage, zéro peut être renvoyé ou une erreur peut être émise au moment de l'exécution.

de face()

Cela renvoie une référence au premier élément du vecteur sans supprimer l'élément. La sortie du code suivant est 1.1.

vecteur vtr1.1, 2.2, 3.3, 4.4 ;
flotteur fl = vtr.de face();
cout << fl << '\n';

L'élément n'est pas supprimé du vecteur.

avant() const

Lorsque la construction vectorielle est précédée de const, l'expression « front() const » est exécutée à la place de « front().” Ceci est utilisé dans le code suivant :

vecteur const vtr1.1, 2.2, 3.3, 4.4 ;
flotteur fl = vtr.de face();
cout << fl << '\n';

Une référence constante est renvoyée. L'élément n'est pas supprimé du vecteur.

dos()

Cela renvoie une référence au dernier élément du vecteur sans supprimer l'élément. La sortie du code suivant est 4.4.

vecteur vtr1.1, 2.2, 3.3, 4.4 ;
float fl = vtr.dos();
cout << fl << '\n';

retour() const

Lorsque la construction vectorielle est précédée de const, l'expression « back() const » est exécutée à la place de « back().” Ceci est utilisé dans le code suivant :

vecteur const vtr1.1, 2.2, 3.3, 4.4 ;
float fl = vtr.dos();
cout << fl << '\n';

Une référence constante est renvoyée. L'élément n'est pas supprimé du vecteur.

Accès aux données vectorielles

data() nonexcept; data() const noexcept;

L'un ou l'autre renvoie un pointeur tel que [data(), data() + size()) est une plage valide.

Cela sera traité plus en détail plus loin dans l'article.

Itérateurs de retour et le vecteur

Un itérateur est comme un pointeur mais a plus de fonctionnalités qu'un pointeur.

begin() nonsauf

Renvoie un itérateur qui pointe vers le premier élément du vecteur, comme dans le segment de code suivant :

vecteur vtr1.1, 2.2, 3.3, 4.4 ;
vecteur::itérateur iter = vtr.commencer();
cout << *iter << '\n';

La sortie est 1.1. Notez que la déclaration qui reçoit l'itérateur a été déclarée. L'itérateur est déréférencé dans une expression de retour pour obtenir la valeur de la même manière qu'un pointeur est déréférencé.

begin() const noexcept;

Renvoie un itérateur qui pointe vers le premier élément du vecteur. Lorsque la construction vectorielle est précédée de const, l'expression "begin() const" est exécutée à la place de "begin().” Dans cette condition, l'élément correspondant dans le vecteur ne peut pas être modifié. Ceci est utilisé dans le code suivant :

vecteur const vtr1.1, 2.2, 3.3, 4.4 ;
vecteur::const_iterator iter = vtr.commencer();
cout << *iter << '\n';

La sortie est 1.1. Notez que "const_iterator" a été utilisé cette fois au lieu de simplement "iterator" pour recevoir l'itérateur renvoyé.

fin() nonsauf

Renvoie un itérateur qui pointe immédiatement au-delà du dernier élément du vecteur. Considérez le segment de code suivant :

vecteur vtr1.1, 2.2, 3.3, 4.4 ;
vecteur::itérateur iter = vtr.finir();
cout << *iter << '\n';

La sortie est 0, ce qui n'a pas de sens, car il n'y a pas d'élément concret au-delà du dernier élément.

end() const noexcept

Renvoie un itérateur qui pointe immédiatement au-delà du dernier élément du vecteur. Lorsque la construction vectorielle est précédée de "const", l'expression "end() const" est exécutée à la place de "end().” Considérez le segment de code suivant :

vecteur const vtr1.1, 2.2, 3.3, 4.4 ;
vecteur::const_iterator iter = vtr.finir();
cout << *iter << '\n';

La sortie est 0. Notez que "const_iterator" a été utilisé cette fois au lieu de simplement "iterator" pour recevoir l'itérateur renvoyé.

Itération inverse

Il est possible d'avoir un itérateur qui itère de la fin juste avant le premier élément.

rbegin() nonsauf

Renvoie un itérateur qui pointe vers le dernier élément du vecteur, comme dans le segment de code suivant :

vecteur vtr1.1, 2.2, 3.3, 4.4 ;
vecteur::reverse_iterator rIter = vtr.rbegin();
cout << *rIter << '\n';

La sortie est de 4.4.

Notez que la déclaration qui reçoit l'itérateur inverse a été déclarée. L'itérateur est déréférencé dans une expression de retour pour obtenir la valeur de la même manière qu'un pointeur est déréférencé.

rbegin() const noexcept;

Renvoie un itérateur qui pointe vers le dernier élément du vecteur. Lorsque la construction vectorielle est précédée de "const", l'expression "rbegin() const" est exécutée au lieu de "rbegin().” Dans cette condition, l'élément correspondant dans le vecteur ne peut pas être modifié. Cette fonctionnalité est utilisée dans le code suivant :

vecteur const vtr1.1, 2.2, 3.3, 4.4 ;
vecteur::const_reverse_iterator rIter = vtr.rbegin();
cout << *rIter << '\n';

La sortie est de 4.4.

Notez que le const_reverse_iterator a été utilisé cette fois, au lieu de simplement le reverse_iterator, pour recevoir l'itérateur renvoyé.

rend() nonsauf

Renvoie un itérateur qui pointe juste avant le premier élément du vecteur. Considérez le segment de code suivant :

vecteur vtr1.1, 2.2, 3.3, 4.4 ;
vecteur::reverse_iterator rIter = vtr.déchirer();
cout << *rIter << '\n';

La sortie est 0, ce qui n'a pas de sens, car il n'y a pas d'élément concret juste avant le premier élément.

rend() const noexcept

Renvoie un itérateur qui pointe juste avant le premier élément du vecteur. Lorsque la construction vectorielle est précédée de "const", l'expression "rend() const" est exécutée à la place de "rend().” Considérez le segment de code suivant :

vecteur const vtr1.1, 2.2, 3.3, 4.4 ;
vecteur::const_reverse_iterator rIter = vtr.déchirer();
cout << *rIter << '\n';

La sortie est 0.

Notez que le const_reverse_iterator a été utilisé cette fois, au lieu de simplement le reverse_iterator, pour recevoir l'itérateur renvoyé.

Modificateurs vectoriels

Un modificateur qui modifie le vecteur peut prendre ou retourner un itérateur.

une.emplace(p, args)

Insère un objet de type T construit avec std::forward(args)… avant p.

Pour plus de détails - voir plus tard

insert(itérateurPosition, valeur)

Insère une copie de la valeur à la position de l'itérateur du vecteur. Renvoie l'itérateur (position) dans le vecteur où la copie a été placée. Le code suivant indique où la valeur a été placée :

vecteur vtr10, 20, 30, 40 ;
vecteur::itérateur iter = vtr.commencer();
++iter;
++iter;
magnétoscope.insérer(iter, 25);
cout << vtr[1] << " << vtr[2]<< '
' << vtr[3] << '\n';

La sortie est : 20 25 30.

Notez que l'itérateur a été avancé (incrémenté) tout comme un pointeur.

Une liste d'initialisation peut également être insérée, comme l'illustre le code suivant :

vecteur vtr10, 20, 30, 40 ;
vecteur::itérateur iter = vtr.commencer();
++iter;
++iter;
magnétoscope.insert(iter, 25, 28);
cout << vtr[1] << " << vtr[2]<< '
' << vtr[3]<< " << vtr[4] << '\n';

La sortie est : 20 25 28 30.

effacer (position)

Supprime un élément à la position pointée par l'itérateur, puis renvoie la position de l'itérateur. Le code suivant illustre cela :

vecteur vtr10, 20, 30, 40 ;
vecteur::itérateur iter = vtr.commencer();
++iter;
++iter;
magnétoscope.effacer(iter);
cout << vtr[0] << " << vtr[1] << '
' << vtr[2]<< '\n';

La sortie est : 10 20 40

push_back(t), push_back(rv)

Utilisé pour ajouter un seul élément à la fin du vecteur. Utilisez push_back(t) comme suit :

vecteur vtr1.1, 2.2, 3.3, 4.4 ;
magnétoscope.push_back(5.5);
flotteur fl = vtr[4];
cout << fl << '\n';

La sortie est de 5.5.

push_back(rv): - voir plus tard.

pop_back()

Supprime le dernier élément sans le retourner. La taille du vecteur est réduite de 1. Le code suivant illustre cela :

vecteur vtr1.1, 2.2, 3.3, 4.4 ;
magnétoscope.pop_back();
flotteur sz = vtr.Taille();
cout << sz << '\n';

La sortie est 3.

une.échange(b)

Deux vecteurs peuvent être échangés, comme illustré dans le segment de code suivant :

vecteur vtr11.1, 2.2, 3.3, 4.4 ;
vecteur vtr210, 20 ;
vtr1.échanger(vtr2) ;
cout << "vtr1: "<< vtr1[0] <<" "<< vtr1[1] <<"
"<< vtr1[2] <<" "<< vtr1[3] << '\n';
cout << "vtr2: "<< vtr2[0] <<" "<< vtr2[1] <<"
"<< vtr2[2] <<" "<< vtr2[3] << '\n';

La sortie est :

vtr1 : 10 20 0 0
vtr2 : 1.1 2.2 3.3 4.4

Notez que la longueur d'un vecteur est augmentée, si nécessaire. De plus, les valeurs qui n'avaient pas de remplacements sont remplacées par une valeur par défaut.

dégager()

Supprime tous les éléments du vecteur, comme l'illustre le segment de code suivant :

vecteur vtr1.1, 2.2, 3.3, 4.4 ;
magnétoscope.dégager();
cout << vtr.size() << '\n';

La sortie est 0.

Égalité et opérateurs relationnels pour les vecteurs

L'opérateur ==

Renvoie 1 pour true si les deux vecteurs ont la même taille et les éléments correspondants sont égaux ; sinon, il renvoie 0 pour faux. Par example:

vecteur U1, 2, 3 ;
vecteur V4, 5, 6 ;
bool bl = U==V;
cout << bl << '\n';

La sortie est 0.

le != Opérateur

Renvoie 1 pour true si les deux vecteurs n'ont pas la même taille et/ou les éléments correspondants ne sont pas égaux ; sinon, il renvoie 0 pour faux. Par example:

vecteur U1, 2, 3 ;
vecteur V4, 5, 6 ;
bool bl = U!=V;
cout << bl << '\n';

La sortie est 1.

le < Operator

Renvoie 1 pour vrai si le premier vecteur est le sous-ensemble initial du deuxième vecteur, avec les éléments des deux parties égales étant les mêmes et dans le même ordre. Si les deux vecteurs sont de la même taille et se déplacent de gauche à droite et qu'un élément est rencontré dans le premier vecteur qui est inférieur à l'élément correspondant dans le deuxième vecteur, alors 1 sera toujours renvoyé. Sinon, 0 pour false est renvoyé. Par example:

vecteur U3, 1, 1 ;
vecteur V3, 2, 1 ;
bool bl = Ucout << bl << '\n';

La sortie est 1. < does not include the case when the size and order are the same.

L'opérateur >

Retour !(U < V), where U is the first vector and V is the second vector, according to the above definitions.

le <= Operator

Retourne U <= V, where U is the first vector and V is the second vector, according to the above definitions.

L'opérateur >=

Retour !(U <= V), where U is the first vector and V is the second vector, according to the above definitions.

Conclusion

Un vecteur est un exemple de conteneur de séquence. Un vecteur est une "meilleure" forme du tableau ordinaire et est instancié à partir d'une classe. Les vecteurs ont des méthodes classées sous : construction et affectation, capacité, accès aux éléments, accès aux données, itérateurs, modificateurs et opérateurs numériques surchargés.

Il existe d'autres conteneurs de séquences, appelés list, forward_list et array. Si la tâche implique des insertions et des suppressions fréquentes au milieu de la séquence, alors une liste ou une forward_list doit être utilisée. Si la tâche implique des insertions et des suppressions fréquentes au début ou à la fin de la séquence, alors un deque doit être utilisé. Et donc, les vecteurs ne doivent être utilisés que lorsque ces types d'opérations ne sont pas importants.