std::vector<T,Allocator>::vector

vector() : vector(Allocator()) {}	(1)	(depuis C++11) (jusqu'à C++17)
vector() noexcept(noexcept(Allocator())) : vector(Allocator()) {}	(1)		(depuis C++17) (constexpr depuis C++20)
explicit vector( const Allocator& alloc = Allocator() );	(2)	(jusqu'à C++11)
explicit vector( const Allocator& alloc );	(2)		(depuis C++11) (noexcept depuis C++17) (constexpr depuis C++20)
explicit vector( size_type count, const Allocator& alloc = Allocator() );	(3)	(depuis C++11)
explicit vector( size_type count, const T& value = T(), const Allocator& alloc = Allocator() );	(4)	(jusqu'à C++11)
vector( size_type count, const T& value, const Allocator& alloc = Allocator() );	(4)		(depuis C++11) (constexpr depuis C++20)
template< class InputIt > vector( InputIt first, InputIt last, const Allocator& alloc = Allocator() );	(5)	(constexpr depuis C++20)
template< container-compatible-range<T> R > constexpr vector( std::from_range_t, R&& rg, const Allocator& alloc = Allocator() );	(6)	(depuis C++23)
vector( const vector& other );	(7)	(constexpr depuis C++20)
vector( vector&& other );	(8)	(depuis C++11) (noexcept depuis C++17) (constexpr depuis C++20)
vector( const vector& other, const Allocator& alloc );	(9)	(depuis C++11) (constexpr depuis C++20) (jusqu'à C++23)
constexpr vector( const vector& other, const std::type_identity_t<Allocator>& alloc );	(9)		(depuis C++23)
vector( vector&& other, const Allocator& alloc );	(10)	(depuis C++11) (constexpr depuis C++20) (jusqu'à C++23)
constexpr vector( vector&& other, const std::type_identity_t<Allocator>& alloc );	(10)		(depuis C++23)
vector( std::initializer_list<T> init, const Allocator& alloc = Allocator() );	(11)	(depuis C++11)

Construit un nouveau vector à partir d'une variété de sources de données, en utilisant éventuellement un allocateur fourni par l'utilisateur alloc.

1) Le constructeur par défaut depuis C++11. Construit un vector vide avec un allocateur construit par défaut.

Si Allocator n'est pas DefaultConstructible, le comportement est indéfini.

2) Le constructeur par défaut jusqu'à C++11. Construit un vector vide avec l'allocateur donné alloc.

3) Construit un vector avec count objets insérés par défaut de type T. Aucune copie n'est effectuée.

Si T n'est pas DefaultInsertable dans std::vector<T>, le comportement est indéfini.

4) Construit un vector avec count copies d'éléments de valeur value.

Si T n'est pas CopyInsertable dans std::vector<T>, le comportement est indéfini.

(depuis C++11)

5) Construit un vector avec le contenu de la plage [first, last). Chaque itérateur dans [first, last) est déréférencé exactement une fois.

Si InputIt ne satisfait pas les exigences de LegacyInputIterator, la surcharge (4) est appelée à la place avec les arguments static_cast<size_type>(first), last et alloc.

(jusqu'à C++11)

Cette surcharge participe à la résolution de surcharge uniquement si InputIt satisfait les exigences de LegacyInputIterator.

Si l'une des conditions suivantes est satisfaite, le comportement est indéfini :

T n'est pas EmplaceConstructible dans std::vector<T> à partir de *first.
Iter ne satisfait pas les exigences de LegacyForwardIterator, et T n'est pas MoveInsertable dans std::vector<T>.

(depuis C++11)

6) Construit un vector avec le contenu de la plage rg. Chaque itérateur dans rg est déréférencé exactement une fois.

Si l'une des conditions suivantes est satisfaite, le comportement est indéfini :

T n'est pas EmplaceConstructible dans std::vector<T> à partir de *ranges::begin(rg).
R ne modélise ni sized_range ni forward_range, et T n'est pas MoveInsertable dans std::vector<T>.

7-10) Construit un vector avec le contenu de other.

7) Le constructeur par copie.

L'allocateur est obtenu comme en appelant std::allocator_traits<Allocator>::select_on_container_copy_construction(alloc) où alloc est l'allocateur de other.

(depuis C++11)

8) Le constructeur par déplacement. L'allocateur est obtenu par construction par déplacement à partir de other.get_allocator().

9) Identique au constructeur par copie, sauf que alloc est utilisé comme allocateur.

Si T n'est pas CopyInsertable dans std::vector<T>, le comportement est indéfini.

10) Identique au constructeur par déplacement, sauf que alloc est utilisé comme allocateur.

Si T n'est pas MoveInsertable dans std::vector<T>, le comportement est indéfini.

11) Équivalent à vector(il.begin(), il.end(), alloc).

Paramètres

alloc	-	allocateur à utiliser pour toutes les allocations mémoire de ce conteneur
count	-	la taille du conteneur
value	-	la valeur pour initialiser les éléments du conteneur
first, last	-	la paire d'itérateurs définissant la plage d'éléments à copier
other	-	un autre conteneur à utiliser comme source pour initialiser les éléments du conteneur
init	-	liste d'initialisation pour initialiser les éléments du conteneur
rg	-	une plage compatible avec le conteneur

Complexité

1,2) Constant.

3,4) Linéaire en count .

5) Soit std:: distance ( first, last ) égal à

N

:

Si InputIt satisfait aux exigences de LegacyForwardIterator , alors :

Le constructeur de copie de T n'est appelé que $N$ fois.
Aucune réallocation ne se produit.

Sinon :

Le constructeur de copie de T est appelé $O(N)$ fois.
La réallocation se produit $O(log N)$ fois.

6) Étant donné ranges:: distance ( rg ) comme

N

:

Si R modélise forward_range ou sized_range , alors :

(jusqu'à C++26)

Si R satisfait l'une des conditions suivantes :

R modélise approximately_sized_range , et ranges:: distance ( rg ) <= ranges :: reserve_hint ( rg ) est true .
R modélise forward_range et R ne modélise pas approximately_sized_range .

alors :

(depuis C++26)

Initialise exactement $N$ éléments à partir du résultat du déréférencement des itérateurs successifs de rg .
Aucune réallocation ne se produit.

Sinon :

Le constructeur de copie ou de déplacement de T est appelé $O(N)$ fois.
La réallocation se produit $O(log N)$ fois.

7) Linéaire en other. size ( ) .

8) Constante.

9) Linéaire en other. size ( ) .

10) Linéaire en other. size ( ) si alloc ! = other. get_allocator ( ) , sinon constant.

11) Linéaire en init. size ( ) .

Exceptions

Les appels à Allocator :: allocate peuvent lever des exceptions.

Notes

Après la construction par déplacement d'un conteneur (surcharge (8)), les références, pointeurs et itérateurs qui se référaient initialement aux éléments dans other restent valides, mais se réfèrent aux éléments qui sont maintenant dans *this. La norme actuelle garantit cela via l'énoncé général dans [container.reqmts]/67, et une garantie plus directe est à l'étude via LWG issue 2321.

Macro de test de fonctionnalité	Valeur	Norme	Fonctionnalité
`__cpp_lib_containers_ranges`	`202202L`	(C++23)	compatibles avec les Ranges construction et insertion ; surcharge (6)

Exemple

Exécuter ce code

#include <iostream>
#include <string>
#include <vector>
template<typename T>
std::ostream& operator<<(std::ostream& s, const std::vector<T>& v)
{
    s.put('{');
    for (char comma[]{'\0', ' ', '\0'}; const auto& e : v)
        s << comma << e, comma[0] = ',';
    return s << "}\n";
}
int main()
{
    // Syntaxe de liste d'initialisation C++11 :
    std::vector<std::string> words1{"the", "frogurt", "is", "also", "cursed"};
    std::cout << "1: " << words1;
    // words2 == words1
    std::vector<std::string> words2(words1.begin(), words1.end());
    std::cout << "2: " << words2;
    // words3 == words1
    std::vector<std::string> words3(words1);
    std::cout << "3: " << words3;
    // words4 est {"Mo", "Mo", "Mo", "Mo", "Mo"}
    std::vector<std::string> words4(5, "Mo");
    std::cout << "4: " << words4;
    const auto rg = {"cat", "cow", "crow"};
#ifdef __cpp_lib_containers_ranges
    std::vector<std::string> words5(std::from_range, rg); // surcharge (6)
#else
    std::vector<std::string> words5(rg.begin(), rg.end()); // surcharge (5)
#endif
    std::cout << "5: " << words5;
}

Sortie :

1: {the, frogurt, is, also, cursed}
2: {the, frogurt, is, also, cursed}
3: {the, frogurt, is, also, cursed}
4: {Mo, Mo, Mo, Mo, Mo}
5: {cat, cow, crow}

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 134	C++98	la surcharge ( 5 ) autorisait jusqu'à $2N$ appels au constructeur de copie dans le cas des itérateurs d'entrée	modifié en $O(N)$ appels
LWG 438	C++98	la surcharge ( 5 ) n'appelait la surcharge ( 4 ) que si `InputIt` était un type intégral	appelle la surcharge ( 4 ) si `InputIt` n'est pas un LegacyInputIterator
LWG 2193	C++11	le constructeur par défaut était explicite	rendu non-explicite
LWG 2210	C++11	la surcharge ( 3 ) n'avait pas de paramètre allocateur	paramètre ajouté
N3346	C++11	pour la surcharge ( 3 ) , les éléments du conteneur étaient initialisés par valeur	ils sont insérés par défaut

Voir aussi

assign	assigne des valeurs au conteneur (fonction membre publique)
operator=	assigne des valeurs au conteneur (fonction membre publique)

Support du compilateur
Autonome et hébergé
Langage
Bibliothèque standard
En-têtes de la bibliothèque standard
Exigences nommées
Macros de test de fonctionnalités (C++20)
Bibliothèque de support du langage
Bibliothèque de concepts (C++20)
Bibliothèque de diagnostics
Bibliothèque de gestion de la mémoire
Bibliothèque de métaprogrammation (C++11)
Bibliothèque d'utilitaires généraux
Bibliothèque de conteneurs
Bibliothèque d'itérateurs
Bibliothèque de plages (C++20)
Bibliothèque d'algorithmes
Bibliothèque de chaînes
Bibliothèque de traitement de texte
Bibliothèque numérique
Bibliothèque de date et heure
Bibliothèque d'entrée/sortie
Bibliothèque de système de fichiers (C++17)
Bibliothèque de support de concurrence (C++11)
Bibliothèque de contrôle d'exécution (C++26)
Spécifications techniques
Index des symboles
Bibliothèques externes

Séquence
array (C++11)
vector
vector<bool>
inplace_vector (C++26)
hive (C++26)
deque
forward_list (C++11)
list
Associatifs
set
multiset
map
multimap
Associatifs non ordonnés
unordered_set (C++11)
unordered_multiset (C++11)
unordered_map (C++11)
unordered_multimap (C++11)
Adaptateurs
stack
queue
priority_queue
flat_set (C++23)
flat_multiset (C++23)
flat_map (C++23)
flat_multimap (C++23)
Vues
span (C++20)
mdspan (C++23)
Tableaux
Invalidation d'itérateur
Tableau des fonctions membres
Tableau des fonctions non membres

fr.cppreference.net

Namespaces

Variants

std::vector<T,Allocator>::vector

Sommaire

Paramètres

Complexité

Exceptions

Notes

Exemple

Rapports de défauts

Voir aussi