Classe `vector`

Article
08/25/2023

La classe de vecteur de bibliothèque standard C++ est un modèle de classe pour les conteneurs de séquences. Un vecteur stocke les éléments d’un type donné dans une disposition linéaire et permet un accès aléatoire rapide à n’importe quel élément. Un vecteur est le conteneur préféré pour une séquence lorsque les performances d’accès aléatoire sont à un niveau premium.

Syntaxe

template <class Type, class Allocator = allocator<Type>>
class vector

Paramètres

Type
Type de données des éléments à stocker dans le vecteur.

Allocator
Type qui représente l'objet allocateur stocké qui contient des informations détaillées sur l'allocation et la désallocation de mémoire du vecteur. Cet argument est facultatif et sa valeur par défaut est allocator<Type>.

Notes

Les vecteurs gèrent les insertions et suppressions en temps fixe à la fin de la séquence. Ailleurs dans le vecteur, les insertions et suppressions d'éléments doivent s'effectuer en temps linéaire. Le deque conteneur de classes est plus rapide lors des insertions et des suppressions au début et à la fin d’une séquence. Le list conteneur de classes est plus rapide lors des insertions et des suppressions à n’importe quel emplacement dans une séquence.

Une réallocation du vecteur se produit quand une fonction membre doit augmenter la taille de la séquence contenue dans l'objet vector au-delà de sa capacité de stockage actuelle. D'autres insertions et suppressions peuvent modifier différentes adresses de stockage dans la séquence. Si cela se produit, les itérateurs ou les références qui pointent vers des parties modifiées dans la séquence deviennent non valides. En l'absence de réallocation, seuls les itérateurs et références situés avant le point d'insertion ou de suppression restent valides.

La vector<bool> classe est une spécialisation complète du vecteur de modèle de classe pour les éléments de type bool. Il a un allocateur pour le type sous-jacent utilisé par la spécialisation.

La vector<bool> classe de référence est une classe imbriquée dont les objets peuvent fournir des références à des éléments (bits uniques) dans un vector<bool> objet.

Membres

Constructeurs

Nom	Description
`vector`	Construit un vecteur de taille spécifique ou contenant des éléments de valeurs spécifiques, ou contenant un objet `allocator` spécifique, ou comme copie d'un autre vecteur.

Typedefs

Nom	Description
`[allocator_type]`(#allocator_type)	Type qui représente la classe `allocator` pour l'objet vector.
`const_iterator`	Type qui fournit un itérateur à accès aléatoire qui peut lire un élément `const` dans un vecteur.
`const_pointer`	Type qui fournit un pointeur vers un élément `const` d'un vecteur.
`const_reference`	Type qui fournit une référence à un `const` élément stocké dans un vecteur. Il est utilisé pour lire et effectuer des `const` opérations.
`const_reverse_iterator`	Type qui fournit un itérateur à accès aléatoire pouvant lire n'importe quel élément `const` dans le vecteur.
`difference_type`	Type qui fournit la différence entre les adresses de deux éléments dans un vecteur.
`iterator`	Type qui fournit un itérateur à accès aléatoire pour lire ou modifier un élément dans un vecteur.
`pointer`	Type qui fournit un pointeur vers un élément d'un vecteur.
`reference`	Type qui fournit une référence à un élément stocké dans un vecteur.
`reverse_iterator`	Type qui fournit un itérateur à accès aléatoire pouvant lire ou modifier un élément d'un vecteur inversé.
`size_type`	Type qui compte le nombre d'éléments dans un vecteur.
`value_type`	Type représentant le type de données stockées dans un vecteur.

Functions

Nom	Description
`assign`	Efface un tableau et copie les éléments spécifiés dans le vecteur vide.
`at`	Retourne une référence à l'élément à un emplacement spécifié dans le vecteur.
`back`	Retourne une référence au dernier élément du vecteur.
`begin`	Retourne un itérateur à accès aléatoire pointant vers le premier élément dans le vecteur.
`capacity`	Retourne le nombre d'éléments que le vecteur peut contenir sans avoir à allouer plus de stockage.
`cbegin`	Retourne un itérateur const à accès aléatoire pointant vers le premier élément du vecteur.
`cend`	Retourne un itérateur const à accès aléatoire qui pointe juste après la fin du vecteur.
`crbegin`	Retourne un itérateur const qui pointe vers le premier élément d'un vecteur inversé.
`crend`	Retourne un itérateur const qui pointe vers la fin d'un vecteur inversé.
`clear`	Supprime les éléments du vecteur.
`data`	Retourne un pointeur vers le premier élément du vecteur.
`emplace`	Insère un élément construit sur place à la position spécifiée dans le vecteur.
`emplace_back`	Ajoute un élément construit sur place à la fin du vecteur.
`empty`	Teste si le conteneur vecteur est vide.
`end`	Retourne un itérateur à accès aléatoire qui pointe vers la fin du vecteur.
`erase`	Supprime un élément ou une plage d'éléments aux positions spécifiées dans le vecteur.
`front`	Retourne une référence au premier élément du vecteur.
`get_allocator`	Retourne un objet à la classe `allocator` utilisée par un vecteur.
`insert`	Insère un élément ou de nombreux éléments dans le vecteur à une position spécifiée.
`max_size`	Retourne la longueur maximale autorisée du vecteur.
`pop_back`	Supprime l'élément à la fin du vecteur.
`push_back`	Ajoute un élément à la fin du vecteur.
`rbegin`	Retourne un itérateur pointant vers le premier élément d'un vecteur inverse.
`rend`	Retourne un itérateur qui pointe vers la fin d'un vecteur inversé.
`reserve`	Réserve une taille de stockage minimale pour un vecteur.
`resize`	Spécifie une nouvelle taille pour un vecteur.
`shrink_to_fit`	Ignore la capacité excédentaire.
`size`	Retourne le nombre d'éléments figurant dans le vecteur.
`swap`	Échange les éléments de deux vecteurs.

Opérateurs

Nom	Description
`operator[]`	Retourne une référence à l'élément de vecteur à un emplacement spécifié.
`operator=`	Remplace les éléments du vecteur par une copie d'un autre vecteur.

`allocator_type`

Type représentant la classe allocator pour l'objet vecteur.

typedef Allocator allocator_type;

Notes

allocator_type est un synonyme du paramètre de modèle Allocator.

Exemple

Consultez l’exemple pour get_allocator obtenir un exemple qui utilise allocator_type.

`assign`

Efface un tableau et copie les éléments spécifiés dans le vecteur vide.

void assign(size_type count, const Type& value);
void assign(initializer_list<Type> init_list);

template <class InputIterator>
void assign(InputIterator first, InputIterator last);

Paramètres

first
Position du premier élément dans la plage d'éléments à copier.

last
Position du premier élément suivant la fin de la plage d'éléments à copier.

count
Nombre de copies d'un élément inséré dans le vecteur.

value
Valeur de l'élément inséré dans le vecteur.

init_list
initializer_list qui contient les éléments à insérer.

Notes

Tout d’abord, assign efface tous les éléments existants dans un vecteur. Ensuite, assign insère une plage d’éléments spécifiée du vecteur d’origine dans un vecteur, ou insère des copies d’un nouvel élément de valeur spécifié dans un vecteur.

Exemple

/ vector_assign.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main()
{
    using namespace std;
    vector<int> v1, v2, v3;

    v1.push_back(10);
    v1.push_back(20);
    v1.push_back(30);
    v1.push_back(40);
    v1.push_back(50);

    cout << "v1 = ";
    for (auto& v : v1){
        cout << v << " ";
    }
    cout << endl;

    v2.assign(v1.begin(), v1.end());
    cout << "v2 = ";
    for (auto& v : v2){
        cout << v << " ";
    }
    cout << endl;

    v3.assign(7, 4);
    cout << "v3 = ";
    for (auto& v : v3){
        cout << v << " ";
    }
    cout << endl;

    v3.assign({ 5, 6, 7 });
    for (auto& v : v3){
        cout << v << " ";
    }
    cout << endl;
}

`at`

Retourne une référence à l'élément à un emplacement spécifié dans le vecteur.

reference at(size_type position);

const_reference at(size_type position) const;

Paramètres

position
Valeur de l'indice ou de la position de l'élément à référencer dans le vecteur.

Valeur retournée

Référence à l’élément en indice dans l’argument. Si position elle est supérieure à la taille du vecteur, at lève une exception.

Notes

Si la valeur de retour d’un at objet vector est affectée à un const_reference, l’objet vectoriel ne peut pas être modifié. Si la valeur de retour de at est assignée à reference, l’objet vector peut être modifié.

Exemple

// vector_at.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;

   v1.push_back( 10 );
   v1.push_back( 20 );

   const int &i = v1.at( 0 );
   int &j = v1.at( 1 );
   cout << "The first element is " << i << endl;
   cout << "The second element is " << j << endl;
}

The first element is 10
The second element is 20

`back`

Retourne une référence au dernier élément du vecteur.

reference back();

const_reference back() const;

Valeur retournée

Dernier élément du vecteur. Si le vecteur est vide, la valeur de retour n'est pas définie.

Notes

Si la valeur de retour d’un back objet vector est affectée à un const_reference, l’objet vectoriel ne peut pas être modifié. Si la valeur de retour de back est assignée à reference, l’objet vector peut être modifié.

Lorsqu’elle est compilée à l’aide de _ITERATOR_DEBUG_LEVEL la valeur 1 ou 2, une erreur d’exécution se produit si vous tentez d’accéder à un élément dans un vecteur vide. Pour plus d’informations, consultez Itérateurs vérifiés.

Exemple

// vector_back.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main() {
   using namespace std;
   vector <int> v1;

   v1.push_back( 10 );
   v1.push_back( 11 );

   int& i = v1.back( );
   const int& ii = v1.front( );

   cout << "The last integer of v1 is " << i << endl;
   i--;
   cout << "The next-to-last integer of v1 is "<< ii << endl;
}

`begin`

Retourne un itérateur à accès aléatoire pointant vers le premier élément dans le vecteur.

const_iterator begin() const;

iterator begin();

Valeur retournée

Itérateur à accès aléatoire qui traite le premier élément dans l’objet vector ou l’emplacement suivant un objet vector vide. Comparez toujours la valeur retournée vector::end pour vous assurer qu’elle est valide.

Notes

Si la valeur de retour d’un begin objet est affectée à un vector::const_iterator, l’objet vector ne peut pas être modifié. Si la valeur de retour d’un begin objet est affectée à un vector::iterator, l’objet vector peut être modifié.

Exemple

// vector_begin.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main()
{
    using namespace std;
    vector<int> c1;
    vector<int>::iterator c1_Iter;
    vector<int>::const_iterator c1_cIter;

    c1.push_back(1);
    c1.push_back(2);

    cout << "The vector c1 contains elements:";
    c1_Iter = c1.begin();
    for (; c1_Iter != c1.end(); c1_Iter++)
    {
        cout << " " << *c1_Iter;
    }
    cout << endl;

    cout << "The vector c1 now contains elements:";
    c1_Iter = c1.begin();
    *c1_Iter = 20;
    for (; c1_Iter != c1.end(); c1_Iter++)
    {
        cout << " " << *c1_Iter;
    }
    cout << endl;

    // The following line would be an error because iterator is const
    // *c1_cIter = 200;
}

The vector c1 contains elements: 1 2
The vector c1 now contains elements: 20 2

`capacity`

Retourne le nombre d'éléments que le vecteur peut contenir sans avoir à allouer plus de stockage.

size_type capacity() const;

Valeur retournée

Longueur actuelle du stockage alloué pour le vecteur.

Notes

La fonction resize membre sera plus efficace si la mémoire suffisante est allouée pour l’adapter. Utilisez la fonction reserve membre pour spécifier la quantité de mémoire allouée.

Exemple

// vector_capacity.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;

   v1.push_back( 1 );
   cout << "The length of storage allocated is "
        << v1.capacity( ) << "." << endl;

   v1.push_back( 2 );
   cout << "The length of storage allocated is now "
        << v1.capacity( ) << "." << endl;
}

The length of storage allocated is 1.
The length of storage allocated is now 2.

`cbegin`

Retourne un itérateur const qui traite le premier élément d'une plage.

const_iterator cbegin() const;

Valeur retournée

Itérateur d'accès aléatoire const qui pointe vers le premier élément de la plage, ou vers l'emplacement situé juste après la fin d'une plage vide (pour une plage vide : cbegin() == cend()).

Notes

Avec la valeur de retour , les éléments de cbeginla plage ne peuvent pas être modifiés.

Vous pouvez utiliser cette fonction membre à la place de la fonction membre begin() afin de garantir que la valeur de retour est const_iterator. En règle générale, il est utilisé avec le mot clé de déduction de auto type, comme illustré dans l’exemple suivant. Dans cet exemple, Container est supposé être un conteneur modifiable (autre que const) de type indéfini prenant en charge begin() et cbegin().

auto i1 = Container.begin();
// i1 is Container<T>::iterator
auto i2 = Container.cbegin();

// i2 is Container<T>::const_iterator

`cend`

Retourne un const itérateur past-the-end qui pointe vers l’élément suivant le dernier élément du vecteur.

const_iterator cend() const;

Valeur retournée

Itérateur const past-the-end pour le vecteur. Il pointe vers l’élément suivant le dernier élément du vecteur. Cet élément est un espace réservé et ne doit pas être déréférencement. Utilisez-le uniquement pour les comparaisons. Si le vecteur est vide, alors vector::cend() == vector::cbegin().

Notes

cend est utilisé pour vérifier si un itérateur a dépassé la fin de la plage.

Vous pouvez utiliser cette fonction membre à la place de la fonction membre end() afin de garantir que la valeur de retour est const_iterator. En règle générale, il est utilisé avec le auto mot clé de déduction de type, comme illustré dans l’exemple suivant. Dans cet exemple, Container est supposé être un conteneur modifiable (autre que const) de type indéfini prenant en charge end() et cend().

auto i1 = Container.end();
// i1 is Container<T>::iterator
auto i2 = Container.cend();

// i2 is Container<T>::const_iterator

La valeur retournée par cend ne doit pas être déréférencement. Utilisez-le uniquement pour les comparaisons.

`clear`

Supprime les éléments du vecteur.

void clear();

Exemple

// vector_clear.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;

   v1.push_back( 10 );
   v1.push_back( 20 );
   v1.push_back( 30 );

   cout << "The size of v1 is " << v1.size( ) << endl;
   v1.clear( );
   cout << "The size of v1 after clearing is " << v1.size( ) << endl;
}

The size of v1 is 3
The size of v1 after clearing is 0

`const_iterator`

Type qui fournit un itérateur à accès aléatoire qui peut lire un élément const dans un vecteur.

typedef implementation-defined const_iterator;

Notes

Un type const_iterator ne peut pas être utilisé pour modifier la valeur d’un élément.

Exemple

Consultez l’exemple back illustrant l’utilisation de const_iterator.

`const_pointer`

Type qui fournit un pointeur vers un élément const d'un vecteur.

typedef typename Allocator::const_pointer const_pointer;

Notes

Un type const_pointer ne peut pas être utilisé pour modifier la valeur d’un élément.

Un itérateur est généralement utilisé pour fournir un accès à un élément de vecteur.

`const_reference`

Type qui fournit une référence à un const élément stocké dans un vecteur. Il est utilisé pour lire et effectuer des const opérations.

typedef typename Allocator::const_reference const_reference;

Notes

Un type const_reference ne peut pas être utilisé pour modifier la valeur d’un élément.

Exemple

// vector_const_ref.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;

   v1.push_back( 10 );
   v1.push_back( 20 );

   const vector <int> v2 = v1;
   const int &i = v2.front( );
   const int &j = v2.back( );
   cout << "The first element is " << i << endl;
   cout << "The second element is " << j << endl;

   // The following line would cause an error as v2 is const
   // v2.push_back( 30 );
}

The first element is 10
The second element is 20

`const_reverse_iterator`

Type qui fournit un itérateur à accès aléatoire pouvant lire n'importe quel élément const dans le vecteur.

typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

Notes

Un type const_reverse_iterator ne peut pas modifier la valeur d’un élément et est utilisé pour itérer à travers le vecteur en sens inverse.

Exemple

Consultez rbegin un exemple de déclaration et d’utilisation d’un itérateur.

`crbegin`

Retourne un itérateur const qui pointe vers le premier élément d'un vecteur inversé.

const_reverse_iterator crbegin() const;

Valeur retournée

Itérateur d’accès aléatoire inverse const ciblant le premier élément d’un inverse vector ou traitant ce qui avait été le dernier élément dans l’inversion vector.

Notes

Avec la valeur de retour de crbegin, l’objet vector ne peut pas être modifié.

Exemple

// vector_crbegin.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;
   vector <int>::iterator v1_Iter;
   vector <int>::const_reverse_iterator v1_rIter;

   v1.push_back( 1 );
   v1.push_back( 2 );

   v1_Iter = v1.begin( );
   cout << "The first element of vector is "
        << *v1_Iter << "." << endl;

   v1_rIter = v1.crbegin( );
   cout << "The first element of the reversed vector is "
        << *v1_rIter << "." << endl;
}

The first element of vector is 1.
The first element of the reversed vector is 2.

`crend`

Retourne un const itérateur inverse past-the-end qui pointe vers l’élément suivant le dernier élément du vecteur inversé.

const_reverse_iterator crend() const;

Valeur retournée

Itérateur const inverse passé-à-bout pour le vecteur inversé. Il pointe vers l’élément suivant le dernier élément du vecteur inversé, qui est le même que l’élément avant le premier élément du vecteur non inversé. Cet élément est un espace réservé et ne doit pas être déréférencement. Utilisez-le uniquement pour les comparaisons.

Notes

crend est utilisé avec un inverse vector comme vector::cend utilisé avec un vector.

Avec la valeur de retour de crend (décrémentation convenable), l’objet vector ne peut pas être modifié.

crend peut être utilisé pour déterminer si un itérateur inversé a atteint la fin de son objet vector.

La valeur retournée par crend ne doit pas être déréférencement. Utilisez-le uniquement pour les comparaisons.

Exemple

// vector_crend.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;
   vector <int>::const_reverse_iterator v1_rIter;

   v1.push_back( 1 );
   v1.push_back( 2 );

   for ( v1_rIter = v1.rbegin( ) ; v1_rIter != v1.rend( ) ; v1_rIter++ )
      cout << *v1_rIter << endl;
}

2
1

`data`

Retourne un pointeur vers le premier élément du vecteur.

const_pointer data() const;

pointer data();

Valeur retournée

Pointeur vers le premier élément du vector ou vers l’emplacement qui réussit un élément vide vector.

Exemple

// vector_data.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main()
{
    using namespace std;
    vector<int> c1;
    vector<int>::pointer c1_ptr;
    vector<int>::const_pointer c1_cPtr;

    c1.push_back(1);
    c1.push_back(2);

    cout << "The vector c1 contains elements:";
    c1_cPtr = c1.data();
    for (size_t n = c1.size(); 0 < n; --n, c1_cPtr++)
    {
        cout << " " << *c1_cPtr;
    }
    cout << endl;

    cout << "The vector c1 now contains elements:";
    c1_ptr = c1.data();
    *c1_ptr = 20;
    for (size_t n = c1.size(); 0 < n; --n, c1_ptr++)
    {
        cout << " " << *c1_ptr;
    }
    cout << endl;
}

The vector c1 contains elements: 1 2
The vector c1 now contains elements: 20 2

`difference_type`

Type qui fournit la différence entre deux itérateurs qui font référence aux éléments d'un même vecteur.

typedef typename Allocator::difference_type difference_type;

Notes

Un difference_type peut également être décrit comme le nombre d’éléments entre deux pointeurs, car un pointeur vers un élément contient son adresse.

Un itérateur est généralement utilisé pour fournir un accès à un élément de vecteur.

Exemple

// vector_diff_type.cpp
// compile with: /EHsc
#include <iostream>
#include <vector>
#include <algorithm>

int main( )
{
   using namespace std;

   vector <int> c1;
   vector <int>::iterator c1_Iter, c2_Iter;

   c1.push_back( 30 );
   c1.push_back( 20 );
   c1.push_back( 30 );
   c1.push_back( 10 );
   c1.push_back( 30 );
   c1.push_back( 20 );

   c1_Iter = c1.begin( );
   c2_Iter = c1.end( );

   vector <int>::difference_type   df_typ1, df_typ2, df_typ3;

   df_typ1 = count( c1_Iter, c2_Iter, 10 );
   df_typ2 = count( c1_Iter, c2_Iter, 20 );
   df_typ3 = count( c1_Iter, c2_Iter, 30 );
   cout << "The number '10' is in c1 collection " << df_typ1 << " times.\n";
   cout << "The number '20' is in c1 collection " << df_typ2 << " times.\n";
   cout << "The number '30' is in c1 collection " << df_typ3 << " times.\n";
}

The number '10' is in c1 collection 1 times.
The number '20' is in c1 collection 2 times.
The number '30' is in c1 collection 3 times.

`emplace`

Insère un élément construit sur place à la position spécifiée dans le vecteur.

template <class... Types>
iterator emplace(
    const_iterator position,
    Types&&... args);

Paramètres

position
Position dans l’emplacement vector où le premier élément est inséré.

args
Arguments de constructeur. Selon les arguments fournis, la fonction déduit la surcharge de constructeur à appeler.

Valeur retournée

La fonction retourne un itérateur qui pointe vers la position où le nouvel élément a été inséré dans le vector.

Notes

Toute opération d’insertion peut être coûteuse, consultez vector la classe pour une discussion sur vector les performances.

Exemple

// vector_emplace.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;
   vector <int>::iterator Iter;

   v1.push_back( 10 );
   v1.push_back( 20 );
   v1.push_back( 30 );

   cout << "v1 =" ;
   for ( Iter = v1.begin( ) ; Iter != v1.end( ) ; Iter++ )
      cout << " " << *Iter;
   cout << endl;

// initialize a vector of vectors by moving v1
   vector < vector <int> > vv1;

   vv1.emplace( vv1.begin(), move( v1 ) );
   if ( vv1.size( ) != 0 && vv1[0].size( ) != 0 )
      {
      cout << "vv1[0] =";
      for (Iter = vv1[0].begin( ); Iter != vv1[0].end( ); Iter++ )
         cout << " " << *Iter;
      cout << endl;
      }
}

v1 = 10 20 30
vv1[0] = 10 20 30

`emplace_back`

Ajoute un élément construit sur place à la fin du vecteur.

template <class... Types>
void emplace_back(Types&&... args);

Paramètres

args
Arguments de constructeur. Selon les arguments fournis, la fonction déduit la surcharge de constructeur à appeler.

Exemple

#include <vector>
struct obj
{
   obj(int, double) {}
};

int main()
{
   std::vector<obj> v;
   v.emplace_back(1, 3.14); // obj in created in place in the vector
}

`empty`

Teste si le vecteur est vide.

bool empty() const;

Valeur retournée

true si le vecteur est vide ; false si le vecteur n’est pas vide.

Exemple

// vector_empty.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;

   v1.push_back( 10 );

   if ( v1.empty( ) )
      cout << "The vector is empty." << endl;
   else
      cout << "The vector is not empty." << endl;
}

The vector is not empty.

`end`

Retourne un itérateur past-the-end qui pointe vers l’élément suivant le dernier élément du vecteur.

iterator end();

const_iterator end() const;

Valeur retournée

Itérateur past-the-end pour le vecteur. Il pointe vers l’élément suivant le dernier élément du vecteur. Cet élément est un espace réservé et ne doit pas être déréférencement. Utilisez-le uniquement pour les comparaisons. Si le vecteur est vide, alors vector::end() == vector::begin().

Notes

Si la valeur de retour d’une end variable de type const_iteratorest affectée, l’objet vector ne peut pas être modifié. Si la valeur de retour d’une end variable de type iteratorest affectée, l’objet vector peut être modifié.

Exemple

// vector_end.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>
int main( )
{
   using namespace std;
   vector <int> v1;
   vector <int>::iterator v1_Iter;

   v1.push_back( 1 );
   v1.push_back( 2 );

   for ( v1_Iter = v1.begin( ) ; v1_Iter != v1.end( ) ; v1_Iter++ )
      cout << *v1_Iter << endl;
}

1
2

`erase`

Supprime un élément ou une plage d'éléments aux positions spécifiées dans le vecteur.

iterator erase(
    const_iterator position);

iterator erase(
    const_iterator first,
    const_iterator last);

Paramètres

position
Position de l'élément à supprimer du vecteur.

first
Position du premier élément supprimé du vecteur.

last
Position juste après le dernier élément supprimé du vecteur.

Valeur retournée

Itérateur qui désigne le premier élément restant après tous les éléments supprimés, ou pointeur vers la fin du vecteur si aucun élément de ce genre n'existe.

Exemple

// vector_erase.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;
   vector <int>::iterator Iter;

   v1.push_back( 10 );
   v1.push_back( 20 );
   v1.push_back( 30 );
   v1.push_back( 40 );
   v1.push_back( 50 );

   cout << "v1 =" ;
   for ( Iter = v1.begin( ) ; Iter != v1.end( ) ; Iter++ )
      cout << " " << *Iter;
   cout << endl;

   v1.erase( v1.begin( ) );
   cout << "v1 =";
   for ( Iter = v1.begin( ) ; Iter != v1.end( ) ; Iter++ )
      cout << " " << *Iter;
   cout << endl;

   v1.erase( v1.begin( ) + 1, v1.begin( ) + 3 );
   cout << "v1 =";
   for ( Iter = v1.begin( ) ; Iter != v1.end( ) ; Iter++ )
      cout << " " << *Iter;
   cout << endl;
}

v1 = 10 20 30 40 50
v1 = 20 30 40 50
v1 = 20 50

`front`

Retourne une référence au premier élément du vecteur.

reference front();

const_reference front() const;

Valeur retournée

Référence au premier élément du vecteur. Si le vecteur est vide, la valeur de retour n'est pas définie.

Notes

Si la valeur de retour d’un front objet vector est affectée à un const_reference, l’objet vectoriel ne peut pas être modifié. Si la valeur de retour de front est assignée à reference, l’objet vector peut être modifié.

Exemple

// vector_front.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;

   v1.push_back( 10 );
   v1.push_back( 11 );

   int& i = v1.front( );
   const int& ii = v1.front( );

   cout << "The first integer of v1 is "<< i << endl;
   // by incrementing i, we move the front reference to the second element
   i++;
   cout << "Now, the first integer of v1 is "<< i << endl;
}

`get_allocator`

Retourne une copie de l’objet allocateur utilisé pour construire le vecteur.

Allocator get_allocator() const;

Valeur retournée

Allocateur utilisé par le vecteur.

Notes

Les allocateurs de la classe vector spécifient la façon dont la classe gère le stockage. Les allocateurs par défaut fournis avec les classes de conteneur de bibliothèque C++ Standard suffisent à satisfaire la plupart des besoins en programmation. L’écriture et l’utilisation de votre propre classe d’allocateur est une fonctionnalité C++ avancée.

Exemple

// vector_get_allocator.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   // The following lines declare objects that use the default allocator.
   vector<int> v1;
   vector<int, allocator<int> > v2 = vector<int, allocator<int> >(allocator<int>( )) ;

   // v3 will use the same allocator class as v1
   vector <int> v3( v1.get_allocator( ) );

   vector<int>::allocator_type xvec = v3.get_allocator( );
   // You can now call functions on the allocator class used by vec
}

`insert`

Insère un élément, ou de nombreux éléments, ou une plage d’éléments dans le vecteur à une position spécifiée.

iterator insert(
    const_iterator position,
    const Type& value);

iterator insert(
    const_iterator position,
    Type&& value);

void insert(
    const_iterator position,
    size_type count,
    const Type& value);

template <class InputIterator>
void insert(
    const_iterator position,
    InputIterator first,
    InputIterator last);

Paramètres

position
Position dans le vecteur où le premier élément est inséré.

value
Valeur de l'élément inséré dans le vecteur.

count
Nombre d'éléments insérés dans le vecteur.

first
Position du premier élément de la plage d'éléments à copier.

last
Position du premier élément au-delà de la plage d'éléments à copier.

Valeur retournée

Les deux premières fonctions insert retournent un itérateur qui pointe vers la position où le nouvel élément a été inséré dans le vecteur.

Notes

Comme condition préalable, first et last ne doivent pas être des itérateurs dans le vecteur, ou le comportement est non défini. Toute opération d’insertion peut être coûteuse, consultez vector la classe pour une discussion sur vector les performances.

Exemple

// vector_insert.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;
   vector <int>::iterator Iter;

   v1.push_back( 10 );
   v1.push_back( 20 );
   v1.push_back( 30 );

   cout << "v1 =" ;
   for ( Iter = v1.begin( ) ; Iter != v1.end( ) ; Iter++ )
      cout << " " << *Iter;
   cout << endl;

   v1.insert( v1.begin( ) + 1, 40 );
   cout << "v1 =";
   for ( Iter = v1.begin( ) ; Iter != v1.end( ) ; Iter++ )
      cout << " " << *Iter;
   cout << endl;
   v1.insert( v1.begin( ) + 2, 4, 50 );

   cout << "v1 =";
   for ( Iter = v1.begin( ) ; Iter != v1.end( ) ; Iter++ )
      cout << " " << *Iter;
   cout << endl;

   const auto v2 = v1;
   v1.insert( v1.begin( )+1, v2.begin( )+2, v2.begin( )+4 );
   cout << "v1 =";
   for (Iter = v1.begin( ); Iter != v1.end( ); Iter++ )
      cout << " " << *Iter;
   cout << endl;

// initialize a vector of vectors by moving v1
   vector < vector <int> > vv1;

   vv1.insert( vv1.begin(), move( v1 ) );
   if ( vv1.size( ) != 0 && vv1[0].size( ) != 0 )
      {
      cout << "vv1[0] =";
      for (Iter = vv1[0].begin( ); Iter != vv1[0].end( ); Iter++ )
         cout << " " << *Iter;
      cout << endl;
      }
}

v1 = 10 20 30
v1 = 10 40 20 30
v1 = 10 40 50 50 50 50 20 30
v1 = 10 50 50 40 50 50 50 50 20 30
vv1[0] = 10 50 50 40 50 50 50 50 20 30

`iterator`

Type qui fournit un itérateur à accès aléatoire pour lire ou modifier un élément dans un vecteur.

typedef implementation-defined iterator;

Notes

Un type iterator peut être utilisé pour modifier la valeur d’un élément.

Exemple

Consultez l’exemple pour begin.

`max_size`

Retourne la longueur maximale autorisée du vecteur.

size_type max_size() const;

Valeur retournée

Longueur maximale autorisée du vecteur.

Exemple

// vector_max_size.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;
   vector <int>::size_type i;

   i = v1.max_size( );
   cout << "The maximum possible length of the vector is " << i << "." << endl;
}

`operator[]`

Retourne une référence à l'élément de vecteur à un emplacement spécifié.

reference operator[](size_type position);

const_reference operator[](size_type position) const;

Paramètres

position
Position de l'élément de vecteur.

Valeur retournée

Si la position spécifiée est supérieure ou égale à la taille du conteneur, le résultat est non défini.

Notes

Si la valeur de retour d’un operator[] objet vector est affectée à un const_reference, l’objet vectoriel ne peut pas être modifié. Si la valeur de retour de operator[] est assignée à une référence, l'objet de vecteur peut être modifié.

Lorsqu’elle est compilée à l’aide _ITERATOR_DEBUG_LEVEL de la valeur 1 ou 2, une erreur d’exécution se produit si vous tentez d’accéder à un élément en dehors des limites du vecteur. Pour plus d’informations, consultez Itérateurs vérifiés.

Exemple

// vector_op_ref.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;

   v1.push_back( 10 );
   v1.push_back( 20 );

   int& i = v1[1];
   cout << "The second integer of v1 is " << i << endl;
}

`operator=`

Remplace les éléments du vecteur par une copie d'un autre vecteur.

vector& operator=(const vector& right);

vector& operator=(vector&& right);

Paramètres

right
En vector cours de copie dans le vector.

Notes

Après avoir supprimé les éléments existants dans un objet vector, operator= copie ou déplace le contenu de right dans vector.

Exemple

// vector_operator_as.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector<int> v1, v2, v3;
   vector<int>::iterator iter;

   v1.push_back(10);
   v1.push_back(20);
   v1.push_back(30);
   v1.push_back(40);
   v1.push_back(50);

   cout << "v1 = " ;
   for (iter = v1.begin(); iter != v1.end(); iter++)
      cout << *iter << " ";
   cout << endl;

   v2 = v1;
   cout << "v2 = ";
   for (iter = v2.begin(); iter != v2.end(); iter++)
      cout << *iter << " ";
   cout << endl;

// move v1 into v2
   v2.clear();
   v2 = move(v1);
   cout << "v2 = ";
   for (iter = v2.begin(); iter != v2.end(); iter++)
      cout << *iter << " ";
   cout << endl;
}

`pointer`

Type qui fournit un pointeur vers un élément d'un vecteur.

typedef typename Allocator::pointer pointer;

Notes

Un type pointer peut être utilisé pour modifier la valeur d’un élément.

Exemple

// vector_pointer.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
    using namespace std;
    vector<int> v;
    v.push_back( 11 );
    v.push_back( 22 );

    vector<int>::pointer ptr = &v[0];
    cout << *ptr << endl;
    ptr++;
    cout << *ptr << endl;
    *ptr = 44;
    cout << *ptr << endl;
}

11
22
44

`pop_back`

Supprime l'élément à la fin du vecteur.

void pop_back();

Notes

Pour obtenir un exemple de code, consultez vector::push_back().

`push_back`

Ajoute un élément à la fin du vecteur.

void push_back(const T& value);

void push_back(T&& value);

Paramètres

value
Valeur à affecter à l'élément ajouté à la fin du vecteur.

Exemple

// compile with: /EHsc /W4
#include <vector>
#include <iostream>

using namespace std;

template <typename T> void print_elem(const T& t) {
    cout << "(" << t << ") ";
}

template <typename T> void print_collection(const T& t) {
    cout << "  " << t.size() << " elements: ";

    for (const auto& p : t) {
        print_elem(p);
    }
    cout << endl;
}

int main()
{
    vector<int> v;
    for (int i = 0; i < 10; ++i) {
        v.push_back(10 + i);
    }

    cout << "vector data: " << endl;
    print_collection(v);

    // pop_back() until it's empty, printing the last element as we go
    while (v.begin() != v.end()) {
        cout << "v.back(): "; print_elem(v.back()); cout << endl;
        v.pop_back();
    }
}

`rbegin`

Retourne un itérateur pointant vers le premier élément d'un vecteur inverse.

reverse_iterator rbegin();
const_reverse_iterator rbegin() const;

Valeur retournée

Un itérateur inverse à accès aléatoire qui traite le premier élément d’un vecteur inversé (ou qui traite ce qui était le dernier élément du vecteur non inversé).

Notes

Si la valeur de retour d’un rbegin objet vector est affectée à un const_reverse_iterator, l’objet vectoriel ne peut pas être modifié. Si la valeur de retour de rbegin est assignée à reverse_iterator, l’objet vector peut être modifié.

Exemple

// vector_rbegin.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;
   vector <int>::iterator v1_Iter;
   vector <int>::reverse_iterator v1_rIter;

   v1.push_back( 1 );
   v1.push_back( 2 );

   v1_Iter = v1.begin( );
   cout << "The first element of vector is "
        << *v1_Iter << "." << endl;

   v1_rIter = v1.rbegin( );
   cout << "The first element of the reversed vector is "
        << *v1_rIter << "." << endl;
}

The first element of vector is 1.
The first element of the reversed vector is 2.

`reference`

Type qui fournit une référence à un élément stocké dans un vecteur.

typedef typename Allocator::reference reference;

Exemple

Consultez at un exemple d’utilisation reference dans la classe vector.

`rend`

Retourne un itérateur inverse past-the-end qui pointe vers l’élément suivant le dernier élément du vecteur inversé.

const_reverse_iterator rend() const;
reverse_iterator rend();

Valeur retournée

Itérateur inverse passé-à-bout pour le vecteur inversé. Il pointe vers l’élément suivant le dernier élément du vecteur inversé, qui est le même que l’élément avant le premier élément du vecteur non inversé. Cet élément est un espace réservé et ne doit pas être déréférencement. Utilisez-le uniquement pour les comparaisons.

Notes

rend est utilisé avec un vecteur inversé comme end utilisé avec un vecteur.

Si la valeur de retour d’une rend valeur est affectée à un const_reverse_iterator, l’objet vector ne peut pas être modifié. Si la valeur de retour de rend est assignée à reverse_iterator, l’objet vector peut être modifié.

rend peut être utilisé pour déterminer si un itérateur inversé a atteint la fin de son tableau.

La valeur retournée par rend ne doit pas être déréférencement. Utilisez-le uniquement pour les comparaisons.

Exemple

// vector_rend.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;
   vector <int>::reverse_iterator v1_rIter;

   v1.push_back( 1 );
   v1.push_back( 2 );

   for ( v1_rIter = v1.rbegin( ) ; v1_rIter != v1.rend( ) ; v1_rIter++ )
      cout << *v1_rIter << endl;
}

2
1

`reserve`

Réserve une taille de stockage minimale pour un vecteur, en allouant plus d'espace si nécessaire.

void reserve(size_type count);

Paramètres

count
Taille de stockage minimale à allouer pour le vecteur.

Exemple

// vector_reserve.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;
   //vector <int>::iterator Iter;

   v1.push_back( 1 );
   cout << "Current capacity of v1 = "
      << v1.capacity( ) << endl;
   v1.reserve( 20 );
   cout << "Current capacity of v1 = "
      << v1.capacity( ) << endl;
}

Current capacity of v1 = 1
Current capacity of v1 = 20

`resize`

Spécifie une nouvelle taille pour un vecteur.

void resize(size_type new_size);
void resize(size_type new_size, Type value);

Paramètres

new_size
Nouvelle taille du vecteur.

value
Valeur d'initialisation des nouveaux éléments ajoutés au vecteur si la nouvelle taille est supérieure à la taille d'origine. Si la valeur est omise, les nouveaux objets utilisent leur constructeur par défaut.

Notes

Si la taille du conteneur est inférieure à la taille demandée, new_sizeresize ajoute des éléments au vecteur jusqu’à ce qu’il atteigne la taille demandée. Lorsque la taille du conteneur est supérieure à la taille demandée, resize supprime les éléments les plus proches de la fin du conteneur jusqu’à ce qu’il atteigne la taille new_size. Aucune action n’est effectuée si la taille actuelle du conteneur est identique à la taille demandée.

size reflète la taille actuelle du vecteur.

Exemple

// vectorsizing.cpp
// compile with: /EHsc /W4
// Illustrates vector::reserve, vector::max_size,
// vector::resize, vector::resize, and vector::capacity.
//
// Functions:
//
//    vector::max_size - Returns maximum number of elements vector could
//                       hold.
//
//    vector::capacity - Returns number of elements for which memory has
//                       been allocated.
//
//    vector::size - Returns number of elements in the vector.
//
//    vector::resize - Reallocates memory for vector, preserves its
//                     contents if new size is larger than existing size.
//
//    vector::reserve - Allocates elements for vector to ensure a minimum
//                      size, preserving its contents if the new size is
//                      larger than existing size.
//
//    vector::push_back - Appends (inserts) an element to the end of a
//                        vector, allocating memory for it if necessary.
//
//////////////////////////////////////////////////////////////////////

// The debugger cannot handle symbols more than 255 characters long.
// The C++ Standard Library often creates symbols longer than that.
// The warning can be disabled:
//#pragma warning(disable:4786)

#include <iostream>
#include <vector>
#include <string>

using namespace std;

template <typename C> void print(const string& s, const C& c) {
    cout << s;

    for (const auto& e : c) {
        cout << e << " ";
    }
    cout << endl;
}

void printvstats(const vector<int>& v) {
    cout << "   the vector's size is: " << v.size() << endl;
    cout << "   the vector's capacity is: " << v.capacity() << endl;
    cout << "   the vector's maximum size is: " << v.max_size() << endl;
}

int main()
{
    // declare a vector that begins with 0 elements.
    vector<int> v;

    // Show statistics about vector.
    cout << endl << "After declaring an empty vector:" << endl;
    printvstats(v);
    print("   the vector's contents: ", v);

    // Add one element to the end of the vector.
    v.push_back(-1);
    cout << endl << "After adding an element:" << endl;
    printvstats(v);
    print("   the vector's contents: ", v);

    for (int i = 1; i < 10; ++i) {
        v.push_back(i);
    }
    cout << endl << "After adding 10 elements:" << endl;
    printvstats(v);
    print("   the vector's contents: ", v);

    v.resize(6);
    cout << endl << "After resizing to 6 elements without an initialization value:" << endl;
    printvstats(v);
    print("   the vector's contents: ", v);

    v.resize(9, 999);
    cout << endl << "After resizing to 9 elements with an initialization value of 999:" << endl;
    printvstats(v);
    print("   the vector's contents: ", v);

    v.resize(12);
    cout << endl << "After resizing to 12 elements without an initialization value:" << endl;
    printvstats(v);
    print("   the vector's contents: ", v);

    // Ensure there's room for at least 1000 elements.
    v.reserve(1000);
    cout << endl << "After vector::reserve(1000):" << endl;
    printvstats(v);

    // Ensure there's room for at least 2000 elements.
    v.resize(2000);
    cout << endl << "After vector::resize(2000):" << endl;
    printvstats(v);
}

`reverse_iterator`

Type qui fournit un itérateur à accès aléatoire pouvant lire ou modifier un élément d'un vecteur inversé.

typedef std::reverse_iterator<iterator> reverse_iterator;

Notes

Un type reverse_iterator est utilisé pour itérer le vecteur dans l'ordre inverse.

Exemple

Consultez l’exemple pour rbegin.

`shrink_to_fit`

Ignore la capacité excédentaire.

void shrink_to_fit();

Exemple

// vector_shrink_to_fit.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;
   //vector <int>::iterator Iter;

   v1.push_back( 1 );
   cout << "Current capacity of v1 = "
      << v1.capacity( ) << endl;
   v1.reserve( 20 );
   cout << "Current capacity of v1 = "
      << v1.capacity( ) << endl;
   v1.shrink_to_fit();
   cout << "Current capacity of v1 = "
      << v1.capacity( ) << endl;
}

Current capacity of v1 = 1
Current capacity of v1 = 20
Current capacity of v1 = 1

`size`

Retourne le nombre d'éléments figurant dans le vecteur.

size_type size() const;

Valeur retournée

Longueur actuelle du vecteur.

Exemple

// vector_size.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;
   vector <int>::size_type i;

   v1.push_back( 1 );
   i = v1.size( );
   cout << "Vector length is " << i << "." << endl;

   v1.push_back( 2 );
   i = v1.size( );
   cout << "Vector length is now " << i << "." << endl;
}

Vector length is 1.
Vector length is now 2.

`size_type`

Type qui compte le nombre d'éléments dans un vecteur.

typedef typename Allocator::size_type size_type;

Exemple

Consultez l’exemple pour capacity.

`swap`

Échange les éléments de deux vecteurs.

void swap(
    vector<Type, Allocator>& right);

friend void swap(
    vector<Type, Allocator>& left,
    vector<Type, Allocator>& right);

Paramètres

right
Vecteur fournissant les éléments à permuter. Ou, un vecteur dont les éléments doivent être échangés avec les éléments du vecteur left.

left
Vecteur dont les éléments doivent être échangés avec les éléments du vecteur right.

Exemple

// vector_swap.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1, v2;

   v1.push_back( 1 );
   v1.push_back( 2 );
   v1.push_back( 3 );

   v2.push_back( 10 );
   v2.push_back( 20 );

   cout << "The number of elements in v1 = " << v1.size( ) << endl;
   cout << "The number of elements in v2 = " << v2.size( ) << endl;
   cout << endl;

   v1.swap( v2 );

   cout << "The number of elements in v1 = " << v1.size( ) << endl;
   cout << "The number of elements in v2 = " << v2.size( ) << endl;
}

The number of elements in v1 = 3
The number of elements in v2 = 2

The number of elements in v1 = 2
The number of elements in v2 = 3

`value_type`

Type représentant le type de données stockées dans un vecteur.

typedef typename Allocator::value_type value_type;

Notes

value_type est un synonyme du paramètre de modèle Type.

Exemple

// vector_value_type.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector<int>::value_type AnInt;
   AnInt = 44;
   cout << AnInt << endl;
}

`vector`

Construit un vecteur. Les surcharges construisent un vecteur d’une taille spécifique ou avec des éléments d’une valeur spécifique. Ou, en tant que copie de tout ou partie d’un autre vecteur. Certaines surcharges vous permettent également de spécifier l’allocateur à utiliser.

vector();
explicit vector(const Allocator& allocator);
explicit vector(size_type count);
vector(size_type count, const Type& value);
vector(size_type count, const Type& value, const Allocator& allocator);

vector(const vector& source);
vector(vector&& source);
vector(initializer_list<Type> init_list, const Allocator& allocator);

template <class InputIterator>
vector(InputIterator first, InputIterator last);
template <class InputIterator>
vector(InputIterator first, InputIterator last, const Allocator& allocator);

Paramètres

allocator
Classe allocator à utiliser avec cet objet. get_allocator retourne la classe d’allocator pour l’objet.

count
Nombre d'éléments figurant dans le vecteur construit.

value
Valeur des éléments contenus dans le vecteur construit.

source
Vecteur dont le vecteur construit doit être une copie.

first
Position du premier élément dans la plage d'éléments à copier.

last
Position du premier élément suivant la fin de la plage d'éléments à copier.

init_list
initializer_list Contenant les éléments à copier.

Notes

Tous les constructeurs stockent un objet d’allocator (allocator) et initialisent le vecteur.

Les deux premiers constructeurs spécifient un vecteur initial vide. Le deuxième constructeur spécifie explicitement le type d’allocator (allocator) à utiliser.

Le troisième constructeur spécifie une répétition d'un nombre donné (count) d'éléments de la valeur par défaut pour la classe Type.

Les quatrième et cinquième constructeurs spécifient une répétition d’éléments (count) de valeur value.

Le sixième constructeur spécifie une copie du vecteur source.

Le septième constructeur déplace le vecteur source.

Le huitième constructeur utilise initializer_list pour spécifier les éléments.

Les neuvième et dixième constructeurs copient la plage [first, last) du vecteur.

Exemple

// vector_ctor.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main()
{
    using namespace std;
    vector <int>::iterator v1_Iter, v2_Iter, v3_Iter, v4_Iter, v5_Iter, v6_Iter;

    // Create an empty vector v0
    vector <int> v0;

    // Create a vector v1 with 3 elements of default value 0
    vector <int> v1(3);

    // Create a vector v2 with 5 elements of value 2
    vector <int> v2(5, 2);

    // Create a vector v3 with 3 elements of value 1 and with the allocator
    // of vector v2
    vector <int> v3(3, 1, v2.get_allocator());

    // Create a copy, vector v4, of vector v2
    vector <int> v4(v2);

    // Create a new temporary vector for demonstrating copying ranges
    vector <int> v5(5);
    for (auto i : v5) {
        v5[i] = i;
    }

    // Create a vector v6 by copying the range v5[ first,  last)
    vector <int> v6(v5.begin() + 1, v5.begin() + 3);

    cout << "v1 =";
    for (auto& v : v1){
        cout << " " << v;
    }
    cout << endl;

    cout << "v2 =";
    for (auto& v : v2){
        cout << " " << v;
    }
    cout << endl;

    cout << "v3 =";
    for (auto& v : v3){
        cout << " " << v;
    }
    cout << endl;
    cout << "v4 =";
    for (auto& v : v4){
        cout << " " << v;
    }
    cout << endl;

    cout << "v5 =";
    for (auto& v : v5){
        cout << " " << v;
    }
    cout << endl;

    cout << "v6 =";
    for (auto& v : v6){
        cout << " " << v;
    }
    cout << endl;

    // Move vector v2 to vector v7
    vector <int> v7(move(v2));
    vector <int>::iterator v7_Iter;

    cout << "v7 =";
    for (auto& v : v7){
        cout << " " << v;
    }
    cout << endl;

    cout << "v8 =";
    vector<int> v8{ { 1, 2, 3, 4 } };
    for (auto& v : v8){
        cout << " " << v ;
    }
    cout << endl;
}

v1 = 0 0 0
v2 = 2 2 2 2 2
v3 = 1 1 1
v4 = 2 2 2 2 2
v5 = 0 0 0 0 0
v6 = 0 0
v7 = 2 2 2 2 2
v8 = 1 2 3 4

Voir aussi

Sécurité des threads dans la bibliothèque C++ Standard
Informations de référence sur la bibliothèque standard C++

Partager via

Classe vector

Syntaxe

Paramètres

Notes

Membres

Constructeurs

Typedefs

Functions

Opérateurs

allocator_type

Notes

Exemple

assign

Paramètres

Notes

Exemple

at

Paramètres

Valeur retournée

Notes

Exemple

back

Valeur retournée

Notes

Exemple

begin

Valeur retournée

Notes

Exemple

capacity

Valeur retournée

Notes

Exemple

cbegin

Valeur retournée

Notes

cend

Valeur retournée

Notes

clear

Exemple

const_iterator

Notes

Exemple

const_pointer

Notes

const_reference

Notes

Exemple

const_reverse_iterator

Notes

Exemple

crbegin

Valeur retournée

Notes

Exemple

crend

Valeur retournée

Notes

Exemple

data

Valeur retournée

Exemple

difference_type

Notes

Exemple

emplace

Paramètres

Valeur retournée

Notes

Exemple

emplace_back

Paramètres

Exemple

empty

Valeur retournée

Exemple

end

Valeur retournée

Classe `vector`

`allocator_type`

`assign`

`at`

`back`

`begin`

`capacity`

`cbegin`

`cend`

`clear`

`const_iterator`

`const_pointer`

`const_reference`

`const_reverse_iterator`

`crbegin`

`crend`

`data`

`difference_type`

`emplace`

`emplace_back`

`empty`

`end`

`erase`

`front`

`get_allocator`

`insert`

`iterator`

`max_size`

`operator[]`

`operator=`

`pointer`

`pop_back`

`push_back`

`rbegin`

`reference`

`rend`

`reserve`

`resize`

`reverse_iterator`

`shrink_to_fit`

`size`

`size_type`