Namespaces
Variants

std:: vector

From cppreference.net
Défini dans l'en-tête <vector>
template <

class T,
class Allocator = std:: allocator < T >

> class vector ;
(1)
namespace pmr {

template < class T >
using vector = std :: vector < T, std:: pmr :: polymorphic_allocator < T >> ;

}
(2) (depuis C++17)
1) std::vector est un conteneur séquentiel qui encapsule des tableaux de taille dynamique.
2) std::pmr::vector est un modèle d'alias qui utilise un polymorphic allocator .

Sauf pour la std::vector<bool> spécialisation partielle, les éléments sont stockés de manière contiguë, ce qui signifie que les éléments peuvent être accédés non seulement via des itérateurs, mais également en utilisant des décalages vers des pointeurs classiques vers les éléments. Cela signifie qu'un pointeur vers un élément d'un vecteur peut être passé à toute fonction qui attend un pointeur vers un élément d'un tableau.

Le stockage du vecteur est géré automatiquement, étant étendu selon les besoins. Les vecteurs occupent généralement plus d'espace que les tableaux statiques, car plus de mémoire est allouée pour gérer la croissance future. Ainsi, un vecteur n'a pas besoin de se réallouer à chaque fois qu'un élément est inséré, mais seulement lorsque la mémoire supplémentaire est épuisée. La quantité totale de mémoire allouée peut être interrogée en utilisant la fonction capacity() . La mémoire supplémentaire peut être restituée au système via un appel à shrink_to_fit() [1] .

Les réallocations sont généralement des opérations coûteuses en termes de performance. La fonction reserve() peut être utilisée pour éliminer les réallocations si le nombre d'éléments est connu à l'avance.

La complexité (efficacité) des opérations courantes sur les vecteurs est la suivante :

  • Accès aléatoire - constant 𝓞(1) .
  • Insertion ou suppression d'éléments à la fin - constant amorti 𝓞(1) .
  • Insertion ou suppression d'éléments - linéaire par rapport à la distance jusqu'à la fin du vecteur 𝓞(n) .

std::vector (pour T autre que bool ) satisfait aux exigences de Container , AllocatorAwareContainer (depuis C++11) , SequenceContainer , ContiguousContainer (depuis C++17) et ReversibleContainer .

Toutes les fonctions membres de std::vector sont constexpr : il est possible de créer et d'utiliser des objets std::vector dans l'évaluation d'une expression constante.

Cependant, std::vector ne peut généralement pas être constexpr , car toute mémoire allouée dynamiquement doit être libérée lors de la même évaluation d'expression constante.

(depuis C++20)
  1. Dans libstdc++, shrink_to_fit() n'est pas disponible en mode C++98.

Table des matières

Paramètres du modèle

T - Le type des éléments.
T doit satisfaire aux exigences de CopyAssignable et CopyConstructible . (jusqu'en C++11)
Les exigences imposées aux éléments dépendent des opérations effectivement réalisées sur le conteneur. Généralement, il est requis que le type d'élément soit un type complet et satisfasse aux exigences de Erasable , mais de nombreuses fonctions membres imposent des exigences plus strictes. (depuis C++11)
(jusqu'en C++17)

Les exigences imposées aux éléments dépendent des opérations effectivement réalisées sur le conteneur. Généralement, il est requis que le type d'élément satisfasse aux exigences de Erasable , mais de nombreuses fonctions membres imposent des exigences plus strictes. Ce conteneur (mais pas ses membres) peut être instancié avec un type d'élément incomplet si l'allocateur satisfait aux exigences de complétude de l'allocateur .

Macro de test de fonctionnalité Valeur Std Fonctionnalité
__cpp_lib_incomplete_container_elements 201505L (C++17) Support minimal des types incomplets
(depuis C++17)

Allocateur - Un allocateur qui est utilisé pour acquérir/libérer la mémoire et pour construire/détruire les éléments dans cette mémoire. Le type doit satisfaire aux exigences de Allocator . Le comportement est indéfini (jusqu'en C++20) Le programme est mal formé (depuis C++20) si Allocator::value_type n'est pas le même que T .

Spécialisations

La bibliothèque standard fournit une spécialisation de std::vector pour le type bool , qui peut être optimisée pour l'efficacité de l'espace.

bitset dynamique à efficacité spatiale
(spécialisation de modèle de classe)

Invalidation des itérateurs

Opérations Invalidées
Toutes les opérations en lecture seule Jamais.
swap , std::swap end()
clear , operator= , assign Toujours.
reserve , shrink_to_fit Si la capacité du vecteur a changé, toutes. Sinon, aucune.
erase Les éléments effacés et tous les éléments après eux (y compris end() ).
push_back , emplace_back Si la capacité du vecteur a changé, toutes. Sinon, seulement end() .
insert , emplace Si la capacité du vecteur a changé, toutes.
Sinon, seulement celles à ou après le point d'insertion (y compris end() ).
resize Si la capacité du vecteur a changé, toutes. Sinon, seulement end() et les éléments effacés.
pop_back L'élément effacé et end() .

Types membres

Type de membre Définition
value_type T
allocator_type Allocator
size_type Type entier non signé (généralement std::size_t )
difference_type Type entier signé (généralement std::ptrdiff_t )
reference value_type &
const_reference const value_type &
pointer

Allocator::pointer

(jusqu'à C++11)

std:: allocator_traits < Allocator > :: pointer

(depuis C++11)
const_pointer

Allocator::const_pointer

(jusqu'à C++11)

std:: allocator_traits < Allocator > :: const_pointer

(depuis C++11)
iterator

LegacyRandomAccessIterator et LegacyContiguousIterator vers value_type

(jusqu'à C++20)

LegacyRandomAccessIterator , contiguous_iterator , et ConstexprIterator vers value_type

(depuis C++20)
const_iterator

LegacyRandomAccessIterator et LegacyContiguousIterator vers const value_type

(jusqu'à C++20)

LegacyRandomAccessIterator , contiguous_iterator , et ConstexprIterator vers const value_type

(depuis C++20)
reverse_iterator std:: reverse_iterator < iterator >
const_reverse_iterator std:: reverse_iterator < const_iterator >

Fonctions membres

construit le vector
(fonction membre publique)
détruit le vector
(fonction membre publique)
assigne des valeurs au conteneur
(fonction membre publique)
assigne des valeurs au conteneur
(fonction membre publique)
assigne une plage de valeurs au conteneur
(fonction membre publique)
retourne l'allocateur associé
(fonction membre publique)
Accès aux éléments
accéder à l'élément spécifié avec vérification des limites
(fonction membre publique)
accéder à l'élément spécifié
(fonction membre publique)
accéder au premier élément
(fonction membre publique)
accéder au dernier élément
(fonction membre publique)
accès direct au stockage contigu sous-jacent
(fonction membre publique)
Itérateurs
retourne un itérateur vers le début
(fonction membre publique)
(C++11)
retourne un itérateur vers la fin
(fonction membre publique)
retourne un itérateur inverse vers le début
(fonction membre publique)
(C++11)
retourne un itérateur inverse vers la fin
(fonction membre publique)
Capacité
vérifie si le conteneur est vide
(fonction membre publique)
retourne le nombre d'éléments
(fonction membre publique)
retourne le nombre maximum possible d'éléments
(fonction membre publique)
réserve de l'espace mémoire
(fonction membre publique)
retourne le nombre d'éléments pouvant être contenus dans le stockage actuellement alloué
(fonction membre publique)
réduit l'utilisation de la mémoire en libérant la mémoire inutilisée
(fonction membre publique)
Modificateurs
efface le contenu
(fonction membre publique)
insère des éléments
(fonction membre publique)
insère une plage d'éléments
(fonction membre publique)
(C++11)
construit un élément en place
(fonction membre publique)
efface les éléments
(fonction membre publique)
ajoute un élément à la fin
(fonction membre publique)
construit un élément sur place à la fin
(fonction membre publique)
ajoute une plage d'éléments à la fin
(fonction membre publique)
supprime le dernier élément
(fonction membre publique)
modifie le nombre d'éléments stockés
(fonction membre publique)
échange le contenu
(fonction membre publique)

Fonctions non membres

(supprimé en C++20) (supprimé en C++20) (supprimé en C++20) (supprimé en C++20) (supprimé en C++20) (C++20)
compare lexicographiquement les valeurs de deux vector s
(modèle de fonction)
spécialise l'algorithme std::swap
(modèle de fonction)
efface tous les éléments satisfaisant des critères spécifiques
(modèle de fonction)

Guides de déduction

(depuis C++17)

Notes

Macro de test de fonctionnalité Valeur Std Fonctionnalité
__cpp_lib_containers_ranges 202202L (C++23) Construction et insertion de plages pour les conteneurs
__cpp_lib_ranges_reserve_hint 202502L (C++26) ranges::approximately_sized_range , ranges::reserve_hint , et modifications de std::vector

Exemple

#include <iostream>
#include <vector>
int main()
{
    // Créer un vecteur contenant des entiers
    std::vector<int> v = {8, 4, 5, 9};
    // Ajouter deux entiers supplémentaires au vecteur
    v.push_back(6);
    v.push_back(9);
    // Remplacer l'élément à la position 2
    v[2] = -1;
    // Afficher le vecteur
    for (int n : v)
        std::cout << n << ' ';
    std::cout << '\n';
}

Sortie :

8 4 -1 9 6 9

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR Appliqué à Comportement publié Comportement corrigé
LWG 69 C++98 la contiguïté du stockage pour les éléments de vector n'était pas requise requise
LWG 230 C++98 T n'était pas requis d'être CopyConstructible
(un élément de type T pourrait ne pas pouvoir être construit)
T est également requis
d'être CopyConstructible
LWG 464 C++98 l'accès au stockage sous-jacent d'un vector vide résultait en UB fonction data fournie

Voir aussi

tableau contigu redimensionnable à capacité fixe en place
(modèle de classe)
(C++11)
tableau contigu en place de taille fixe
(modèle de classe)
file double face
(modèle de classe)