Namespaces
Variants

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

From cppreference.net
C++
Containers library
std::vector
Member types
Member functions
Non-member functions
(until C++20) (until C++20) (until C++20) (until C++20) (until C++20)
Deduction guides (C++17)
Seules les parties suivantes ont été traduites : - "(since C++11)" → "(depuis C++11)" Tous les autres éléments (balises HTML, code C++, attributs, termes techniques) ont été conservés intacts conformément aux instructions.
(1)
vector ( ) : vector ( Allocator ( ) ) { }
(depuis C++11)
(jusqu'à C++17)
vector ( ) noexcept ( noexcept ( Allocator ( ) ) ) : vector ( Allocator ( ) ) { }
(depuis C++17)
(constexpr depuis C++20)
(2)
explicit vector ( const Allocator & alloc = Allocator ( ) ) ;
(jusqu'à C++11)
explicit vector ( const Allocator & alloc ) ;
(depuis C++11)
(noexcept depuis C++17)
(constexpr depuis C++20)
explicit vector ( size_type count,
const Allocator & alloc = Allocator ( ) ) ;
(3) (depuis C++11)
(4)
explicit vector ( size_type count, const T & value = T ( ) ,
const Allocator & alloc = Allocator ( ) ) ;
(jusqu'à C++11)
vector ( size_type count, const T & value,
const Allocator & alloc = Allocator ( ) ) ;
(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)
(9)
vector ( const vector & other, const Allocator & alloc ) ;
(depuis C++11)
(constexpr depuis C++20)
(jusqu'à C++23)
constexpr vector ( const vector & other,
const std:: type_identity_t < Allocator > & alloc ) ;
(depuis C++23)
(10)
vector ( vector && other, const Allocator & alloc ) ;
(depuis C++11)
(jusqu'à C++23)
constexpr vector ( vector && other,
const std:: type_identity_t < Allocator > & alloc ) ;
(depuis C++23)
vector ( std:: initializer_list < T > init,
const Allocator & alloc = Allocator ( ) ) ;
(11) (depuis C++11)

Construit un nouveau vector à partir de diverses sources de données, en utilisant optionnellement 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 de T insérés par défaut. Aucune copie n'est effectuée.
Si T n'est pas DefaultInsertable dans vector , 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 vector , 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 aux 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 seulement si InputIt satisfait aux exigences de LegacyInputIterator .

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

(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 :
7) Le constructeur de copie. Construit un vector avec le contenu de other .

L'allocateur est obtenu comme si en appelant
std:: allocator_traits < Allocator > :: select_on_container_copy_construction
( other. get_allocator ( ) ) .

(depuis C++11)
8) Le constructeur de déplacement. Construit un vector avec le contenu de other . L'allocateur est obtenu par construction par déplacement de other. get_allocator ( ) .
9) Identique au constructeur de copie, sauf que alloc est utilisé comme allocateur.
Si T n'est pas CopyInsertable dans vector , le comportement est indéfini.
10) Identique au constructeur de déplacement, sauf que alloc est utilisé comme allocateur.
Si T n'est pas MoveInsertable dans vector , le comportement est indéfini.
11) Équivalent à vector ( il. begin ( ) , il. end ( ) , alloc ) .

Table des matières

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 :
  • 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 :
(jusqu'à C++26)
  • Si R satisfait l'une des conditions suivantes :
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 du conteneur (surcharge ( 8 ) ), les références, pointeurs et itérateurs (à l'exception de l'itérateur de fin) vers other restent valides, mais se réfèrent aux éléments qui se trouvent désormais 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 Std Fonctionnalité
__cpp_lib_containers_ranges 202202L (C++23) Construction et insertion compatibles avec les gammes ; surcharge ( 6 )
__cpp_lib_ranges_reserve_hint 202502L (C++26) ranges::approximately_sized_range et ranges::reserve_hint ; 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

assigne des valeurs au conteneur
(fonction membre publique)
assigne des valeurs au conteneur
(fonction membre publique)