vector (STL/CLR)

La classe de modèle décrit un objet qui contrôle une séquence variable d’éléments ayant un accès aléatoire. Vous utilisez le conteneur vector pour gérer une séquence d’éléments en tant que bloc de stockage contigu. Le bloc est implémenté en tant que tableau qui augmente à la demande.

Dans la description ci-dessous, GValue est identique à Value , sauf si ce dernier est un type ref, auquel cas il s’agit Value^.

Syntaxe

template<typename Value>
    ref class vector
        :   public
        System::ICloneable,
        System::Collections::IEnumerable,
        System::Collections::ICollection,
        System::Collections::Generic::IEnumerable<GValue>,
        System::Collections::Generic::ICollection<GValue>,
        System::Collections::Generic::IList<GValue>,
        Microsoft::VisualC::StlClr::IVector<GValue>
    { ..... };

Paramètres

Valeur
Type d'un élément dans la séquence contrôlée.

Spécifications

Header :<cliext/vector>

Espace de noms : cliext

Déclarations

Définition de type	Description
vector::const_iterator (STL/CLR)	Type d'un itérateur constant pour la séquence contrôlée.
vector::const_reference (STL/CLR)	Type d'une référence constante à un élément.
vector::const_reverse_iterator (STL/CLR)	Type d'un itérateur inserve constant pour la séquence contrôlée.
vector::difference_type (STL/CLR)	Type d'une distance signée entre deux éléments.
vector::generic_container (STL/CLR)	Type de l’interface générique pour le conteneur.
vector::generic_iterator (STL/CLR)	Type d’itérateur pour l’interface générique du conteneur.
vector::generic_reverse_iterator (STL/CLR)	Type d’itérateur inverse pour l’interface générique du conteneur.
vector::generic_value (STL/CLR)	Type d’un élément pour l’interface générique du conteneur.
vector::iterator (STL/CLR)	Type d'un itérateur pour la séquence contrôlée.
vector::reference (STL/CLR)	Type d'une référence à un élément.
vector::reverse_iterator (STL/CLR)	Type d'un itérateur inverse pour la séquence contrôlée.
vector::size_type (STL/CLR)	Type d'une distance signée entre deux éléments.
vector::value_type (STL/CLR)	Type d’un élément.

Fonction membre	Description
vector::assign (STL/CLR)	Remplace tous les éléments.
vector::at (STL/CLR)	Accède à un élément à une position spécifiée.
vector::back (STL/CLR)	Accède au dernier élément.
vector::begin (STL/CLR)	Désigne le début de la séquence contrôlée.
vector::capacity (STL/CLR)	Signale la taille du stockage alloué pour le conteneur.
vector::clear (STL/CLR)	Supprime tous les éléments.
vector::empty (STL/CLR)	Vérifie l'absence d'éléments.
vector::end (STL/CLR)	Désigne la fin de la séquence contrôlée.
vector::erase (STL/CLR)	Supprime les éléments placés aux positions spécifiées.
vector::front (STL/CLR)	Accède au premier élément.
vector::insert (STL/CLR)	Ajoute des éléments à une position spécifiée.
vector::pop_back (STL/CLR)	Supprime le dernier élément.
vector::push_back (STL/CLR)	Ajoute un nouvel élément.
vector::rbegin (STL/CLR)	Désigne le début de la séquence contrôlée inverse.
vector::rend (STL/CLR)	Désigne la fin de la séquence contrôlée inverse.
vector::reserve (STL/CLR)	Garantit une capacité de croissance minimale pour le conteneur.
vector::resize (STL/CLR)	Modifie le nombre d’éléments.
vector::size (STL/CLR)	Compte le nombre d'éléments.
vector::swap (STL/CLR)	Échange le contenu de deux conteneurs.
vector::to_array (STL/CLR)	Copie la séquence contrôlée dans un nouveau tableau.
vector::vector (STL/CLR)	Construit un objet conteneur.

Propriété	Description
vector::back_item (STL/CLR)	Accède au dernier élément.
vector::front_item (STL/CLR)	Accède au premier élément.

Opérateur	Description
vector::operator= (STL/CLR)	Remplace la séquence contrôlée.
vector::operator(STL/CLR)	Accède à un élément à une position spécifiée.
operator!= (vector) (STL/CLR)	Détermine si un vector objet n’est pas égal à un autre vector objet.
opérateur< (vector) (STL/CLR)	Détermine si un vector objet est inférieur à un autre vector objet.
operator<= (vector) (STL/CLR)	Détermine si un vector objet est inférieur ou égal à un autre vector objet.
operator== (vector) (STL/CLR)	Détermine si un vector objet est égal à un autre vector objet.
opérateur> (vector) (STL/CLR)	Détermine si un vector objet est supérieur à un autre vector objet.
operator>= (vector) (STL/CLR)	Détermine si un vector objet est supérieur ou égal à un autre vector objet.

Interfaces

Interface	Description
ICloneable	Dupliquer un objet.
IEnumerable	Séquencer des éléments.
ICollection	Conservez le groupe d’éléments.
IEnumerable<T>	Séquence à l’aide d’éléments typés.
ICollection<T>	Conservez le groupe d’éléments typés.
IList<T>	Conservez le groupe ordonné d’éléments typés.
Valeur IVector<>	Gérer le conteneur générique.

Notes

L’objet alloue et libère le stockage pour la séquence qu’il contrôle via un tableau stocké d’éléments Value , qui augmente à la demande. La croissance se produit de telle sorte que le coût d’ajout d’un nouvel élément est amorti en temps constant. En d’autres termes, le coût d’ajout d’éléments à la fin n’augmente pas, en moyenne, car la longueur de la séquence contrôlée est plus grande. Par conséquent, un vecteur est un bon candidat pour le conteneur sous-jacent pour la pile de classes de modèle (STL/CLR).

Un vector itérateur d’accès aléatoire prend en charge les itérateurs, ce qui signifie que vous pouvez faire référence à un élément directement en fonction de sa position numérique, en comptant de zéro pour le premier élément (avant), jusqu’au size() - 1 dernier élément (précédent). Cela signifie également qu’un vecteur est un bon candidat pour le conteneur sous-jacent pour la classe de modèle priority_queue (STL/CLR).

Un itérateur de vecteur stocke un handle dans son objet vectoriel associé, ainsi que le biais de l’élément qu’il désigne. Vous pouvez utiliser des itérateurs uniquement avec leurs objets conteneur associés. Le biais d’un élément vectoriel est identique à sa position.

L’insertion ou l’effacement d’éléments peuvent modifier la valeur de l’élément stockée à une position donnée, de sorte que la valeur désignée par un itérateur peut également changer. (Le conteneur peut avoir à copier des éléments vers le haut ou vers le bas pour créer un trou avant une insertion ou pour remplir un trou après une effacement.) Néanmoins, un itérateur de vecteur reste valide tant que son biais se trouve dans la plage [0, size()]. En outre, un itérateur valide reste déreferencable - vous pouvez l’utiliser pour accéder ou modifier la valeur de l’élément qu’il désigne -- tant que son biais n’est pas égal à size().

L’effacement ou la suppression d’un élément appelle le destructeur pour sa valeur stockée. La destruction du conteneur efface tous les éléments. Ainsi, un conteneur dont le type d’élément est une classe ref garantit qu’aucun élément n’est hors service du conteneur. Notez toutefois qu’un conteneur de handles ne détruit pas ses éléments.

Membres

vector::assign (STL/CLR)

Remplace tous les éléments.

Syntaxe

void assign(size_type count, value_type val);
template<typename InIt>
    void assign(InIt first, InIt last);
void assign(System::Collections::Generic::IEnumerable<Value>^ right);

Paramètres

count
Nombre d’éléments à insérer.

first
Début de la plage à insérer.

last
Fin de la plage à insérer.

right
Énumération à insérer.

val
Valeur de l’élément à insérer.

Notes

La première fonction membre remplace la séquence contrôlée par une répétition de nombre d’éléments de valeur val. Vous l’utilisez pour remplir le conteneur avec des éléments ayant toutes la même valeur.

S’il InIt s’agit d’un type entier, la deuxième fonction membre se comporte de la même façon que assign((size_type)first, (value_type)last). Sinon, il remplace la séquence contrôlée par la séquence [first, last). Vous l’utilisez pour rendre la séquence contrôlée une copie d’une autre séquence.

La troisième fonction membre remplace la séquence contrôlée par la séquence désignée par le droit de l’énumérateur. Vous l’utilisez pour rendre la séquence contrôlée une copie d’une séquence décrite par un énumérateur.

Exemple

// cliext_vector_assign.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

// assign a repetition of values
    cliext::vector<wchar_t> c2;
    c2.assign(6, L'x');
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// assign an iterator range
    c2.assign(c1.begin(), c1.end() - 1);
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// assign an enumeration
    c2.assign(   // NOTE: cast is not needed
        (System::Collections::Generic::IEnumerable<wchar_t>^)%c1);
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

x x x x x x
a b
a b c

vector::at (STL/CLR)

Accède à un élément à une position spécifiée.

Syntaxe

reference at(size_type pos);

Paramètres

pos
Position de l'élément auquel accéder.

Notes

La fonction membre retourne une référence à l’élément de la séquence contrôlée à la position . Vous l’utilisez pour lire ou écrire un élément dont vous connaissez la position.

Exemple

// cliext_vector_at.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

// display contents " a b c" using at
    for (int i = 0; i < c1.size(); ++i)
        System::Console::Write("{0} ", c1.at(i));
    System::Console::WriteLine();

// change an entry and redisplay
    c1.at(1) = L'x';
    for (int i = 0; i < c1.size(); ++i)
        System::Console::Write("{0} ", c1[i]);
    System::Console::WriteLine();
    return (0);
    }

a b c
a x c

vector::back (STL/CLR)

Accède au dernier élément.

Syntaxe

reference back();

Notes

La fonction membre retourne une référence au dernier élément de la séquence contrôlée, qui doit être non vide. Vous l’utilisez pour accéder au dernier élément, lorsque vous savez qu’il existe.

Exemple

// cliext_vector_back.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

// display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// inspect last item
    System::Console::WriteLine("back() = {0}", c1.back());

// alter last item and reinspect
    c1.back() = L'x';
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
back() = c
a b x

vector::back_item (STL/CLR)

Accède au dernier élément.

Syntaxe

property value_type back_item;

Notes

La propriété accède au dernier élément de la séquence contrôlée, qui doit être non vide. Vous l’utilisez pour lire ou écrire le dernier élément, lorsque vous savez qu’il existe.

Exemple

// cliext_vector_back_item.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

// display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// inspect last item
    System::Console::WriteLine("back_item = {0}", c1.back_item);

// alter last item and reinspect
    c1.back_item = L'x';
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
back_item = c
a b x

vector::begin (STL/CLR)

Désigne le début de la séquence contrôlée.

Syntaxe

iterator begin();

Notes

La fonction membre retourne un itérateur d’accès aléatoire qui désigne le premier élément de la séquence contrôlée, ou juste au-delà de la fin d’une séquence vide. Vous l’utilisez pour obtenir un itérateur qui désigne le current début de la séquence contrôlée, mais son état peut changer si la longueur de la séquence contrôlée change.

Exemple

// cliext_vector_begin.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

// display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// inspect first two items
    cliext::vector<wchar_t>::iterator it = c1.begin();
    System::Console::WriteLine("*begin() = {0}", *it);
    System::Console::WriteLine("*++begin() = {0}", *++it);

// alter first two items and reinspect
    *--it = L'x';
    *++it = L'y';
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
*begin() = a
*++begin() = b
x y c

vector::capacity (STL/CLR)

Signale la taille du stockage alloué pour le conteneur.

Syntaxe

size_type capacity();

Notes

La fonction membre retourne le stockage actuellement alloué pour contenir la séquence contrôlée, une valeur au moins aussi grande que vector ::size (STL/CLR)(). Vous l’utilisez pour déterminer la quantité de croissance du conteneur avant de devoir réallouer le stockage pour la séquence contrôlée.

Exemple

// cliext_vector_capacity.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

// display initial contents " a b c"
    for (int i = 0; i < c1.size(); ++i)
        System::Console::Write("{0} ", c1.at(i));
    System::Console::WriteLine();

// increase capacity
    cliext::vector<wchar_t>::size_type cap = c1.capacity();
    System::Console::WriteLine("capacity() = {0}, ok = {1}",
        cap, c1.size() <= cap);
    c1.reserve(cap + 5);
    System::Console::WriteLine("capacity() = {0}, ok = {1}",
        c1.capacity(), cap + 5 <= c1.capacity());
    return (0);
    }

a b c
capacity() = 4, ok = True
capacity() = 9, ok = True

vector::clear (STL/CLR)

Supprime tous les éléments.

Syntaxe

void clear();

Notes

La fonction membre appelle effectivement vector ::erase (STL/CLR)(vector ::begin (STL/CLR)(),vector ::end (STL/CLR)()). Vous l’utilisez pour vous assurer que la séquence contrôlée est vide.

Exemple

// cliext_vector_clear.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

// display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// clear the container and reinspect
    c1.clear();
    System::Console::WriteLine("size() = {0}", c1.size());

// add elements and clear again
    c1.push_back(L'a');
    c1.push_back(L'b');

    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    c1.clear();
    System::Console::WriteLine("size() = {0}", c1.size());
    return (0);
    }

a b c
size() = 0
a b
size() = 0

vector::const_iterator (STL/CLR)

Type d'un itérateur constant pour la séquence contrôlée.

Syntaxe

typedef T2 const_iterator;

Notes

Le type décrit un objet de type T2 non spécifié qui peut servir d’itérateur d’accès aléatoire constant pour la séquence contrôlée.

Exemple

// cliext_vector_const_iterator.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

// display contents " a b c"
    cliext::vector<wchar_t>::const_iterator cit = c1.begin();
    for (; cit != c1.end(); ++cit)
        System::Console::Write("{0} ", *cit);
    System::Console::WriteLine();
    return (0);
    }

a b c

vector::const_reference (STL/CLR)

Type d'une référence constante à un élément.

Syntaxe

typedef value_type% const_reference;

Notes

Le type décrit une référence constante à un élément.

Exemple

// cliext_vector_const_reference.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

// display initial contents " a b c"
    cliext::vector<wchar_t>::const_iterator cit = c1.begin();
    for (; cit != c1.end(); ++cit)
        {   // get a const reference to an element
        cliext::vector<wchar_t>::const_reference cref = *cit;
        System::Console::Write("{0} ", cref);
        }
    System::Console::WriteLine();
    return (0);
    }

a b c

vector::const_reverse_iterator (STL/CLR)

Type d’itérateur inverse constant pour la séquence contrôlée.

Syntaxe

typedef T4 const_reverse_iterator;

Notes

Le type décrit un objet de type T4 non spécifié qui peut servir d’itérateur inverse constant pour la séquence contrôlée.

Exemple

// cliext_vector_const_reverse_iterator.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

// display contents " a b c" reversed
    cliext::vector<wchar_t>::const_reverse_iterator crit = c1.rbegin();
    cliext::vector<wchar_t>::const_reverse_iterator crend = c1.rend();
    for (; crit != crend; ++crit)
        System::Console::Write("{0} ", *crit);
    System::Console::WriteLine();
    return (0);
    }

c b a

vector::difference_type (STL/CLR)

Types d’une distance signée entre deux éléments.

Syntaxe

typedef int difference_type;

Notes

Le type décrit un nombre d’éléments signés.

Exemple

// cliext_vector_difference_type.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

// display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// compute positive difference
    cliext::vector<wchar_t>::difference_type diff = 0;
    for (cliext::vector<wchar_t>::iterator it = c1.begin();
        it != c1.end(); ++it) ++diff;
    System::Console::WriteLine("end()-begin() = {0}", diff);

// compute negative difference
    diff = 0;
    for (cliext::vector<wchar_t>::iterator it = c1.end();
        it != c1.begin(); --it) --diff;
    System::Console::WriteLine("begin()-end() = {0}", diff);
    return (0);
    }

a b c
end()-begin() = 3
begin()-end() = -3

vector::empty (STL/CLR)

Vérifie l'absence d'éléments.

Syntaxe

bool empty();

Notes

La fonction membre retourne la valeur true pour une séquence contrôlée vide. Il est équivalent à vector ::size (STL/CLR)() == 0. Vous l’utilisez pour tester si le vecteur est vide.

Exemple

// cliext_vector_empty.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

// display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    System::Console::WriteLine("size() = {0}", c1.size());
    System::Console::WriteLine("empty() = {0}", c1.empty());

// clear the container and reinspect
    c1.clear();
    System::Console::WriteLine("size() = {0}", c1.size());
    System::Console::WriteLine("empty() = {0}", c1.empty());
    return (0);
    }

a b c
size() = 3
empty() = False
size() = 0
empty() = True

vector::end (STL/CLR)

Désigne la fin de la séquence contrôlée.

Syntaxe

iterator end();

Notes

La fonction membre retourne un itérateur d’accès aléatoire qui pointe juste au-delà de la fin de la séquence contrôlée. Vous l’utilisez pour obtenir un itérateur qui désigne la current fin de la séquence contrôlée, mais son état peut changer si la longueur de la séquence contrôlée change.

Exemple

// cliext_vector_end.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

// display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// inspect last two items
    cliext::vector<wchar_t>::iterator it = c1.end();
    --it;
    System::Console::WriteLine("*-- --end() = {0}", *--it);
    System::Console::WriteLine("*--end() = {0}", *++it);

// alter first two items and reinspect
    *--it = L'x';
    *++it = L'y';
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
*-- --end() = b
*--end() = c
a x y

vector::erase (STL/CLR)

Supprime les éléments placés aux positions spécifiées.

Syntaxe

iterator erase(iterator where);
iterator erase(iterator first, iterator last);

Paramètres

first
Début de la plage à effacer.

last
Fin de la plage à effacer.

where
Élément à effacer.

Notes

La première fonction membre supprime l’élément de la séquence contrôlée vers laquelle. Vous l’utilisez pour supprimer un seul élément.

La deuxième fonction membre supprime l’élément de la séquence contrôlée dans la plage [first, last). Vous l’utilisez pour supprimer zéro ou plusieurs éléments contigus.

Les deux fonctions membres retournent un itérateur qui désigne le premier élément restant au-delà des éléments supprimés, ou vector ::end (STL/CLR)() s’il n’existe aucun élément de ce type.

Lors de l’effacement des éléments, le nombre de copies d’éléments est linéaire dans le nombre d’éléments entre la fin de l’effacement et la fin la plus proche de la séquence. (Lors de l’effacement d’un ou plusieurs éléments à la fin de la séquence, aucun élément ne se produit.)

Exemple

// cliext_vector_erase.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

// display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// erase an element and reinspect
    System::Console::WriteLine("erase(begin()) = {0}",
        *c1.erase(c1.begin()));

// add elements and display " b c d e"
    c1.push_back(L'd');
    c1.push_back(L'e');
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// erase all but end
    cliext::vector<wchar_t>::iterator it = c1.end();
    System::Console::WriteLine("erase(begin(), end()-1) = {0}",
        *c1.erase(c1.begin(), --it));
    System::Console::WriteLine("size() = {0}", c1.size());
    return (0);
    }

a b c
erase(begin()) = b
b c d e
erase(begin(), end()-1) = e
size() = 1

vector::front (STL/CLR)

Accède au premier élément.

Syntaxe

reference front();

Notes

La fonction membre retourne une référence au premier élément de la séquence contrôlée, qui doit être non vide. Vous l’utilisez pour lire ou écrire le premier élément, lorsque vous savez qu’il existe.

Exemple

// cliext_vector_front.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

// display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// inspect first item
    System::Console::WriteLine("front() = {0}", c1.front());

// alter first item and reinspect
    c1.front() = L'x';
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
front() = a
x b c

vector::front_item (STL/CLR)

Accède au premier élément.

Syntaxe

property value_type front_item;

Notes

La propriété accède au premier élément de la séquence contrôlée, qui doit être non vide. Vous l’utilisez pour lire ou écrire le premier élément, lorsque vous savez qu’il existe.

Exemple

// cliext_vector_front_item.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

// display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// inspect first item
    System::Console::WriteLine("front_item = {0}", c1.front_item);

// alter first item and reinspect
    c1.front_item = L'x';
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
front_item = a
x b c

vector::generic_container (STL/CLR)

Type de l’interface générique pour le conteneur.

Syntaxe

typedef Microsoft::VisualC::StlClr::
    IVector<generic_value>
    generic_container;

Notes

Le type décrit l’interface générique pour cette classe de conteneur de modèle.

Exemple

// cliext_vector_generic_container.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

// display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// construct a generic container
    cliext::vector<wchar_t>::generic_container^ gc1 = %c1;
    for each (wchar_t elem in gc1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// modify generic and display original
    gc1->insert(gc1->end(), L'd');
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// modify original and display generic
    c1.push_back(L'e');

    System::Collections::IEnumerator^ enum1 =
        gc1->GetEnumerator();
    while (enum1->MoveNext())
        System::Console::Write("{0} ", enum1->Current);
    System::Console::WriteLine();
    return (0);
    }

a b c
a b c
a b c d
a b c d e

vector::generic_iterator (STL/CLR)

Type d’itérateur à utiliser avec l’interface générique du conteneur.

Syntaxe

typedef Microsoft::VisualC::StlClr::Generic::
    ContainerRandomAccessIterator<generic_value>
    generic_iterator;

Notes

Le type décrit un itérateur générique qui peut être utilisé avec l’interface générique pour cette classe de conteneur de modèle.

Exemple

// cliext_vector_generic_iterator.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

// display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// construct a generic container
    cliext::vector<wchar_t>::generic_container^ gc1 = %c1;
    for each (wchar_t elem in gc1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// modify generic and display original
    cliext::vector<wchar_t>::generic_iterator gcit = gc1->begin();
    cliext::vector<wchar_t>::generic_value gcval = *gcit;
    *++gcit = gcval;
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
a b c
a a c

vector::generic_reverse_iterator (STL/CLR)

Type d’itérateur inverse à utiliser avec l’interface générique du conteneur.

Syntaxe

typedef Microsoft::VisualC::StlClr::Generic::
    ReverseRandomAccessIterator<generic_value> generic_reverse_iterator;

Notes

Le type décrit un itérateur inverse générique qui peut être utilisé avec l’interface générique pour cette classe de conteneur de modèle.

Exemple

// cliext_vector_generic_reverse_iterator.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

// display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// construct a generic container
    cliext::vector<wchar_t>::generic_container^ gc1 = %c1;
    for each (wchar_t elem in gc1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// modify generic and display original
    cliext::vector<wchar_t>::generic_reverse_iterator gcit = gc1->rbegin();
    cliext::vector<wchar_t>::generic_value gcval = *gcit;
    *++gcit = gcval;
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
a b c
a c c

vector::generic_value (STL/CLR)

Type d’un élément à utiliser avec l’interface générique du conteneur.

Syntaxe

typedef GValue generic_value;

Notes

Le type décrit un objet de type GValue qui décrit la valeur de l’élément stocké à utiliser avec l’interface générique pour cette classe de conteneur de modèle.

Exemple

// cliext_vector_generic_value.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

// display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// construct a generic container
    cliext::vector<wchar_t>::generic_container^ gc1 = %c1;
    for each (wchar_t elem in gc1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// modify generic and display original
    cliext::vector<wchar_t>::generic_iterator gcit = gc1->begin();
    cliext::vector<wchar_t>::generic_value gcval = *gcit;
    *++gcit = gcval;
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
a b c
a a c

vector::insert (STL/CLR)

Ajoute des éléments à une position spécifiée.

Syntaxe

iterator insert(iterator where, value_type val);
void insert(iterator where, size_type count, value_type val);
template<typename InIt>
    void insert(iterator where, InIt first, InIt last);
void insert(iterator where,
    System::Collections::Generic::IEnumerable<Value>^ right);

Paramètres

count
Nombre d’éléments à insérer.

first
Début de la plage à insérer.

last
Fin de la plage à insérer.

right
Énumération à insérer.

val
Valeur de l’élément à insérer.

where
Emplacement dans le conteneur à insérer avant.

Notes

Chacune des fonctions membres insère, avant l’élément pointé vers l’endroit où , dans la séquence contrôlée, une séquence spécifiée par les opérandes restants.

La première fonction membre insère un élément avec valeur val et retourne un itérateur qui désigne l’élément nouvellement inséré. Vous l’utilisez pour insérer un élément unique avant un emplacement désigné par un itérateur.

La deuxième fonction membre insère une répétition de nombre d’éléments de valeur val. Vous l’utilisez pour insérer zéro ou plusieurs éléments contigus qui sont toutes des copies de la même valeur.

Si InIt est un type entier, la troisième fonction membre se comporte comme insert(where, (size_type)first, (value_type)last). Sinon, il insère la séquence [first, last). Vous l’utilisez pour insérer zéro ou plusieurs éléments contigus copiés à partir d’une autre séquence.

La quatrième fonction membre insère la séquence désignée par la droite. Vous l’utilisez pour insérer une séquence décrite par un énumérateur.

Lors de l’insertion d’un élément unique, le nombre de copies d’éléments est linéaire dans le nombre d’éléments entre le point d’insertion et la fin la plus proche de la séquence. (Lors de l’insertion d’un ou de plusieurs éléments à la fin de la séquence, aucun élément ne se produit.) S’il InIt s’agit d’un itérateur d’entrée, la troisième fonction membre effectue efficacement une insertion unique pour chaque élément de la séquence. Sinon, lors de l’insertion d’éléments N , le nombre de copies d’éléments est linéaire en N plus du nombre d’éléments entre le point d’insertion et la fin plus proche de la séquence.

Exemple

// cliext_vector_insert.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

// display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// insert a single value using iterator
    cliext::vector<wchar_t>::iterator it = c1.begin();
    System::Console::WriteLine("insert(begin()+1, L'x') = {0}",
        *c1.insert(++it, L'x'));
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// insert a repetition of values
    cliext::vector<wchar_t> c2;
    c2.insert(c2.begin(), 2, L'y');
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// insert an iterator range
    it = c1.end();
    c2.insert(c2.end(), c1.begin(), --it);
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// insert an enumeration
    c2.insert(c2.begin(),   // NOTE: cast is not needed
        (System::Collections::Generic::IEnumerable<wchar_t>^)%c1);
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
insert(begin()+1, L'x') = x
a x b c
y y
y y a x b
a x b c y y a x b

vector::iterator (STL/CLR)

Type d'un itérateur pour la séquence contrôlée.

Syntaxe

typedef T1 iterator;

Notes

Le type décrit un objet de type T1 non spécifié qui peut servir d’itérateur d’accès aléatoire pour la séquence contrôlée.

Exemple

// cliext_vector_iterator.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

// display contents " a b c"
    cliext::vector<wchar_t>::iterator it = c1.begin();
    for (; it != c1.end(); ++it)
        System::Console::Write("{0} ", *it);
    System::Console::WriteLine();

// alter first element and redisplay
    it = c1.begin();
    *it = L'x';
    for (; it != c1.end(); ++it)
        System::Console::Write("{0} ", *it);
    System::Console::WriteLine();
    return (0);
    }

a b c
x b c

vector::operator= (STL/CLR)

Remplace la séquence contrôlée.

Syntaxe

vector<Value>% operator=(vector<Value>% right);

Paramètres

right
Conteneur à copier.

Notes

L’opérateur membre copie le droit vers l’objet, puis retourne *this. Vous l’utilisez pour remplacer la séquence contrôlée par une copie de la séquence contrôlée à droite.

Exemple

// cliext_vector_operator_as.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

// display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// assign to a new container
    cliext::vector<wchar_t> c2;
    c2 = c1;
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
a b c

vector::operator(STL/CLR)

Accède à un élément à une position spécifiée.

Syntaxe

reference operator[](size_type pos);

Paramètres

pos
Position de l'élément auquel accéder.

Notes

L’opérateur membre retourne un référencen à l’élément à la position de position. Vous l’utilisez pour accéder à un élément dont vous connaissez la position.

Exemple

// cliext_vector_operator_sub.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

// display contents " a b c" using subscripting
    for (int i = 0; i < c1.size(); ++i)
        System::Console::Write("{0} ", c1[i]);
    System::Console::WriteLine();

// change an entry and redisplay
    c1[1] = L'x';
    for (int i = 0; i < c1.size(); ++i)
        System::Console::Write("{0} ", c1[i]);
    System::Console::WriteLine();
    return (0);
    }

a b c
a x c

vector::pop_back (STL/CLR)

Supprime le dernier élément.

Syntaxe

void pop_back();

Notes

La fonction membre supprime le dernier élément de la séquence contrôlée, qui doit être non vide. Vous l’utilisez pour raccourcir le vecteur d’un élément à l’arrière.

Exemple

// cliext_vector_pop_back.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

// display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// pop an element and redisplay
    c1.pop_back();
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
a b

vector::push_back (STL/CLR)

Ajoute un nouvel élément.

Syntaxe

void push_back(value_type val);

Notes

La fonction membre insère un élément avec une valeur val à la fin de la séquence contrôlée. Vous l’utilisez pour ajouter un autre élément au vecteur.

Exemple

// cliext_vector_push_back.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

// display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c

vector::rbegin (STL/CLR)

Désigne le début de la séquence contrôlée inverse.

Syntaxe

reverse_iterator rbegin();

Notes

La fonction membre retourne un itérateur inverse qui désigne le dernier élément de la séquence contrôlée, ou juste au-delà du début d’une séquence vide. Par conséquent, il désigne la beginning séquence inverse. Vous l’utilisez pour obtenir un itérateur qui désigne le current début de la séquence contrôlée vue dans l’ordre inverse, mais son état peut changer si la longueur de la séquence contrôlée change.

Exemple

// cliext_vector_rbegin.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

// display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// inspect first two items in reversed sequence
    cliext::vector<wchar_t>::reverse_iterator rit = c1.rbegin();
    System::Console::WriteLine("*rbegin() = {0}", *rit);
    System::Console::WriteLine("*++rbegin() = {0}", *++rit);

// alter first two items and reinspect
    *--rit = L'x';
    *++rit = L'y';
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
*rbegin() = c
*++rbegin() = b
a y x

vector::reference (STL/CLR)

Type d'une référence à un élément.

Syntaxe

typedef value_type% reference;

Notes

Le type décrit une référence à un élément.

Exemple

// cliext_vector_reference.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

// display initial contents " a b c"
    cliext::vector<wchar_t>::iterator it = c1.begin();
    for (; it != c1.end(); ++it)
        {   // get a reference to an element
        cliext::vector<wchar_t>::reference ref = *it;
        System::Console::Write("{0} ", ref);
        }
    System::Console::WriteLine();

// modify contents " a b c"
    for (it = c1.begin(); it != c1.end(); ++it)
        {   // get a reference to an element
        cliext::vector<wchar_t>::reference ref = *it;

        ref += (wchar_t)(L'A' - L'a');
        System::Console::Write("{0} ", ref);
        }
    System::Console::WriteLine();
    return (0);
    }

a b c
A B C

vector::rend (STL/CLR)

Désigne la fin de la séquence contrôlée inverse.

Syntaxe

reverse_iterator rend();

Notes

La fonction membre retourne un itérateur inverse qui pointe juste au-delà du début de la séquence contrôlée. Par conséquent, il désigne la end séquence inverse. Vous l’utilisez pour obtenir un itérateur qui désigne la current fin de la séquence contrôlée vue dans l’ordre inverse, mais son état peut changer si la longueur de la séquence contrôlée change.

Exemple

// cliext_vector_rend.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

// display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// inspect first two items
    cliext::vector<wchar_t>::reverse_iterator rit = c1.rend();
    --rit;
    System::Console::WriteLine("*-- --rend() = {0}", *--rit);
    System::Console::WriteLine("*--rend() = {0}", *++rit);

// alter first two items and reinspect
    *--rit = L'x';
    *++rit = L'y';
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
*-- --rend() = b
*--rend() = a
y x c

vector::reserve (STL/CLR)

Garantit une capacité de croissance minimale pour le conteneur.

Syntaxe

void reserve(size_type count);

Paramètres

count
Nouvelle capacité minimale du conteneur.

Notes

La fonction membre garantit que capacity() désormais retourne au moins le nombre. Vous l’utilisez pour vous assurer que le conteneur n’a pas besoin de réaffecter le stockage pour la séquence contrôlée tant qu’il n’a pas augmenté à la taille spécifiée.

Exemple

// cliext_vector_reserve.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

// display initial contents " a b c"
    for (int i = 0; i < c1.size(); ++i)
        System::Console::Write("{0} ", c1.at(i));
    System::Console::WriteLine();

// increase capacity
    cliext::vector<wchar_t>::size_type cap = c1.capacity();
    System::Console::WriteLine("capacity() = {0}, ok = {1}",
        cap, c1.size() <= cap);
    c1.reserve(cap + 5);
    System::Console::WriteLine("capacity() = {0}, ok = {1}",
        c1.capacity(), cap + 5 <= c1.capacity());
    return (0);
    }

a b c
capacity() = 4, ok = True
capacity() = 9, ok = True

vector::resize (STL/CLR)

Modifie le nombre d’éléments.

Syntaxe

void resize(size_type new_size);
void resize(size_type new_size, value_type val);

Paramètres

new_size
Nouvelle taille de la séquence contrôlée.

val
Valeur de l’élément de remplissage.

Notes

Les fonctions membres garantissent tous deux que vector ::size (STL/CLR)() retourne désormais new_size. Si elle doit rendre la séquence contrôlée plus longue, la première fonction membre ajoute des éléments avec valeur value_type(), tandis que la deuxième fonction membre ajoute des éléments avec valeur val. Pour raccourcir la séquence contrôlée, les deux fonctions membres effacent efficacement le dernier vecteur d’élément ::size (STL/CLR).() -new_size Vous l’utilisez pour vous assurer que la séquence contrôlée a une taille new_size, en rognant ou en remplissage de la séquence contrôlée actuelle.

Exemple

// cliext_vector_resize.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
// construct an empty container and pad with default values
    cliext::vector<wchar_t> c1;
    System::Console::WriteLine("size() = {0}", c1.size());
    c1.resize(4);
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", (int)elem);
    System::Console::WriteLine();

// resize to empty
    c1.resize(0);
    System::Console::WriteLine("size() = {0}", c1.size());

// resize and pad
    c1.resize(5, L'x');
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

size() = 0
0 0 0 0
size() = 0
x x x x x

vector::reverse_iterator (STL/CLR)

Type d'un itérateur inverse pour la séquence contrôlée.

Syntaxe

typedef T3 reverse_iterator;

Notes

Le type décrit un objet de type T3 non spécifié qui peut servir d’itérateur inverse pour la séquence contrôlée.

Exemple

// cliext_vector_reverse_iterator.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

// display contents " a b c" reversed
    cliext::vector<wchar_t>::reverse_iterator rit = c1.rbegin();
    for (; rit != c1.rend(); ++rit)
        System::Console::Write("{0} ", *rit);
    System::Console::WriteLine();

// alter first element and redisplay
    rit = c1.rbegin();
    *rit = L'x';
    for (; rit != c1.rend(); ++rit)
        System::Console::Write("{0} ", *rit);
    System::Console::WriteLine();
    return (0);
    }

c b a
x b a

vector::size (STL/CLR)

Compte le nombre d'éléments.

Syntaxe

size_type size();

Notes

La fonction membre retourne la longueur de la séquence contrôlée. Vous l’utilisez pour déterminer le nombre d’éléments actuellement dans la séquence contrôlée. Si tout ce dont vous vous souciez est de savoir si la séquence a une taille différente de zéro, consultez vector ::empty (STL/CLR)().

Exemple

// cliext_vector_size.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

// display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    System::Console::WriteLine("size() = {0} starting with 3", c1.size());

// clear the container and reinspect
    c1.clear();
    System::Console::WriteLine("size() = {0} after clearing", c1.size());

// add elements and clear again
    c1.push_back(L'a');
    c1.push_back(L'b');
    System::Console::WriteLine("size() = {0} after adding 2", c1.size());
    return (0);
    }

a b c
size() = 3 starting with 3
size() = 0 after clearing
size() = 2 after adding 2

vector::size_type (STL/CLR)

Type d'une distance signée entre deux éléments.

Syntaxe

typedef int size_type;

Notes

Le type décrit un nombre d’éléments non négatifs.

Exemple

// cliext_vector_size_type.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

// display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// compute positive difference
    cliext::vector<wchar_t>::size_type diff = c1.end() - c1.begin();
    System::Console::WriteLine("end()-begin() = {0}", diff);
    return (0);
    }

a b c
end()-begin() = 3

vector::swap (STL/CLR)

Échange le contenu de deux conteneurs.

Syntaxe

void swap(vector<Value>% right);

Paramètres

right
Conteneur avec lequel échanger le contenu.

Notes

La fonction membre échange les séquences contrôlées entre *this et droite. Il le fait en temps constant et ne lève aucune exception. Vous l’utilisez comme moyen rapide d’échanger le contenu de deux conteneurs.

Exemple

// cliext_vector_swap.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

// display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// construct another container with repetition of values
    cliext::vector<wchar_t> c2(5, L'x');
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// swap and redisplay
    c1.swap(c2);
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
x x x x x
x x x x x
a b c

vector::to_array (STL/CLR)

Copie la séquence contrôlée dans un nouveau tableau.

Syntaxe

cli::array<Value>^ to_array();

Notes

La fonction membre retourne un tableau contenant la séquence contrôlée. Vous l’utilisez pour obtenir une copie de la séquence contrôlée sous forme de tableau.

Exemple

// cliext_vector_to_array.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

// copy the container and modify it
    cli::array<wchar_t>^ a1 = c1.to_array();

    c1.push_back(L'd');
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// display the earlier array copy
    for each (wchar_t elem in a1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c d
a b c

vector::value_type (STL/CLR)

Type d’un élément.

Syntaxe

typedef Value value_type;

Notes

Le type est un synonyme de la valeur du paramètre de modèle.

Exemple

// cliext_vector_value_type.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

// display contents " a b c" using value_type
    for (cliext::vector<wchar_t>::iterator it = c1.begin();
        it != c1.end(); ++it)
        {   // store element in value_type object
        cliext::vector<wchar_t>::value_type val = *it;

        System::Console::Write("{0} ", val);
        }
    System::Console::WriteLine();
    return (0);
    }

a b c

vector::vector (STL/CLR)

Construit un objet conteneur.

Syntaxe

vector();
vector(vector<Value>% right);
vector(vector<Value>^ right);
explicit vector(size_type count);
vector(size_type count, value_type val);
template<typename InIt>
    vector(InIt first, InIt last);
vector(System::Collections::Generic::IEnumerable<Value>^ right);

Paramètres

count
Nombre d’éléments à insérer.

first
Début de la plage à insérer.

last
Fin de la plage à insérer.

right
Objet ou plage à insérer.

val
Valeur de l’élément à insérer.

Notes

Constructeur :

vector();

initialise la séquence contrôlée sans éléments. Vous l’utilisez pour spécifier une séquence contrôlée initiale vide.

Constructeur :

vector(vector<Value>% right);

initialise la séquence contrôlée avec la séquence [right.begin(), right.end()). Vous l’utilisez pour spécifier une séquence contrôlée initiale qui est une copie de la séquence contrôlée par la droite de l’objet vector.

Constructeur :

vector(vector<Value>^ right);

initialise la séquence contrôlée avec la séquence [right->begin(), right->end()). Vous l’utilisez pour spécifier une séquence contrôlée initiale qui est une copie de la séquence contrôlée par l’objet vector dont le handle est correct.

Constructeur :

explicit vector(size_type count);

initialise la séquence contrôlée avec des éléments de nombre chacun avec la valeur value_type(). Vous l’utilisez pour remplir le conteneur avec des éléments qui ont toutes la valeur par défaut.

Constructeur :

vector(size_type count, value_type val);

initialise la séquence contrôlée avec des éléments de nombre chacun avec valeur val. Vous l’utilisez pour remplir le conteneur avec des éléments ayant toutes la même valeur.

Constructeur :

template<typename InIt>

vector(InIt first, InIt last);

initialise la séquence contrôlée avec la séquence [first, last). Vous l’utilisez pour faire de la séquence contrôlée une copie d’une autre séquence.

Constructeur :

vector(System::Collections::Generic::IEnumerable<Value>^ right);

initialise la séquence contrôlée avec la séquence désignée par la droite de l’énumérateur. Vous l’utilisez pour rendre la séquence contrôlée une copie d’une autre séquence décrite par un énumérateur.

Exemple

// cliext_vector_construct.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
// construct an empty container
    cliext::vector<wchar_t> c1;
    System::Console::WriteLine("size() = {0}", c1.size());

// construct with a repetition of default values
    cliext::vector<wchar_t> c2(3);
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", (int)elem);
    System::Console::WriteLine();

// construct with a repetition of values
    cliext::vector<wchar_t> c3(6, L'x');
    for each (wchar_t elem in c3)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// construct with an iterator range
    cliext::vector<wchar_t>::iterator it = c3.end();
    cliext::vector<wchar_t> c4(c3.begin(), --it);
    for each (wchar_t elem in c4)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// construct with an enumeration
    cliext::vector<wchar_t> c5(   // NOTE: cast is not needed
        (System::Collections::Generic::IEnumerable<wchar_t>^)%c3);
    for each (wchar_t elem in c5)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// construct by copying another container
    cliext::vector<wchar_t> c7(c3);
    for each (wchar_t elem in c7)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// construct by copying a container handle
    cliext::vector<wchar_t> c8(%c3);
    for each (wchar_t elem in c8)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    return (0);
    }

size() = 0
0 0 0
x x x x x x
x x x x x
x x x x x x
x x x x x x
x x x x x x

operator!= (vector) (STL/CLR)

Comparaison vectorielle non égale.

Syntaxe

template<typename Value>
    bool operator!=(vector<Value>% left,
        vector<Value>% right);

Paramètres

left
Conteneur de gauche à comparer.

right
Conteneur de droite à comparer.

Notes

La fonction d’opérateur retourne !(left == right). Vous l’utilisez pour tester si la gauche n’est pas ordonnée de la même façon que la droite lorsque les deux vecteurs sont comparés par élément.

Exemple

// cliext_vector_operator_ne.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

// display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// assign to a new container
    cliext::vector<wchar_t> c2;
    c2.push_back(L'a');
    c2.push_back(L'b');
    c2.push_back(L'd');

// display contents " a b d"
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    System::Console::WriteLine("[a b c] != [a b c] is {0}",
        c1 != c1);
    System::Console::WriteLine("[a b c] != [a b d] is {0}",
        c1 != c2);
    return (0);
    }

a b c
a b d
[a b c] != [a b c] is False
[a b c] != [a b d] is True

operator< (vecteur) (STL/CLR)

Vecteur inférieur à la comparaison.

Syntaxe

template<typename Value>
    bool operator<(vector<Value>% left,
        vector<Value>% right);

Paramètres

left
Conteneur de gauche à comparer.

right
Conteneur de droite à comparer.

Notes

La fonction d’opérateur retourne true si, pour la position i la plus basse pour laquelle !(right[i] < left[i]) il est également vrai que left[i] < right[i]. Sinon, elle retourne left->size() < right->size() vous permet de tester si la gauche est ordonnée avant la droite lorsque les deux vecteurs sont comparés par élément.

Exemple

// cliext_vector_operator_lt.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

// display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// assign to a new container
    cliext::vector<wchar_t> c2;
    c2.push_back(L'a');
    c2.push_back(L'b');
    c2.push_back(L'd');

// display contents " a b d"
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    System::Console::WriteLine("[a b c] < [a b c] is {0}",
        c1 < c1);
    System::Console::WriteLine("[a b c] < [a b d] is {0}",
        c1 < c2);
    return (0);
    }

a b c
a b d
[a b c] < [a b c] is False
[a b c] < [a b d] is True

operator<= (vecteur) (STL/CLR)

Vecteur inférieur ou égal à la comparaison.

Syntaxe

template<typename Value>
    bool operator<=(vector<Value>% left,
        vector<Value>% right);

Paramètres

left
Conteneur de gauche à comparer.

right
Conteneur de droite à comparer.

Notes

La fonction d’opérateur retourne !(right < left). Vous l’utilisez pour tester si la gauche n’est pas ordonnée après la droite lorsque les deux vecteurs sont comparés par élément.

Exemple

// cliext_vector_operator_le.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

// display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// assign to a new container
    cliext::vector<wchar_t> c2;
    c2.push_back(L'a');
    c2.push_back(L'b');
    c2.push_back(L'd');

// display contents " a b d"
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    System::Console::WriteLine("[a b c] <= [a b c] is {0}",
        c1 <= c1);
    System::Console::WriteLine("[a b d] <= [a b c] is {0}",
        c2 <= c1);
    return (0);
    }

a b c
a b d
[a b c] <= [a b c] is True
[a b d] <= [a b c] is False

operator== (vector) (STL/CLR)

Comparaison de vecteurs égaux.

Syntaxe

template<typename Value>
    bool operator==(vector<Value>% left,
        vector<Value>% right);

Paramètres

left
Conteneur de gauche à comparer.

right
Conteneur de droite à comparer.

Notes

La fonction opérateur retourne true uniquement si les séquences contrôlées par gauche et droite ont la même longueur et, pour chaque position i, left[i] ==right[i]. Vous l’utilisez pour tester si la gauche est ordonnée de la même façon que la droite lorsque les deux vecteurs sont comparés par élément.

Exemple

// cliext_vector_operator_eq.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

// display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// assign to a new container
    cliext::vector<wchar_t> c2;
    c2.push_back(L'a');
    c2.push_back(L'b');
    c2.push_back(L'd');

// display contents " a b d"
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    System::Console::WriteLine("[a b c] == [a b c] is {0}",
        c1 == c1);
    System::Console::WriteLine("[a b c] == [a b d] is {0}",
        c1 == c2);
    return (0);
    }

a b c
a b d
[a b c] == [a b c] is True
[a b c] == [a b d] is False

operator> (vecteur) (STL/CLR)

Vecteur supérieur à la comparaison.

Syntaxe

template<typename Value>
    bool operator>(vector<Value>% left,
        vector<Value>% right);

Paramètres

left
Conteneur de gauche à comparer.

right
Conteneur de droite à comparer.

Notes

La fonction d’opérateur retourne right<left. Vous l’utilisez pour tester si la gauche est ordonnée après la droite lorsque les deux vecteurs sont comparés par élément.

Exemple

// cliext_vector_operator_gt.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

// display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// assign to a new container
    cliext::vector<wchar_t> c2;
    c2.push_back(L'a');
    c2.push_back(L'b');
    c2.push_back(L'd');

// display contents " a b d"
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    System::Console::WriteLine("[a b c] > [a b c] is {0}",
        c1 > c1);
    System::Console::WriteLine("[a b d] > [a b c] is {0}",
        c2 > c1);
    return (0);
    }

a b c
a b d
[a b c] > [a b c] is False
[a b d] > [a b c] is True

operator>= (vecteur) (STL/CLR)

Vecteur supérieur ou égal à la comparaison.

Syntaxe

template<typename Value>
    bool operator>=(vector<Value>% left,
        vector<Value>% right);

Paramètres

left
Conteneur de gauche à comparer.

right
Conteneur de droite à comparer.

Notes

La fonction d’opérateur retourne !(left < right). Vous l’utilisez pour tester si la gauche n’est pas ordonnée avant la droite lorsque les deux vecteurs sont comparés par élément.

Exemple

// cliext_vector_operator_ge.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

// display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// assign to a new container
    cliext::vector<wchar_t> c2;
    c2.push_back(L'a');
    c2.push_back(L'b');
    c2.push_back(L'd');

// display contents " a b d"
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    System::Console::WriteLine("[a b c] >= [a b c] is {0}",
        c1 >= c1);
    System::Console::WriteLine("[a b c] >= [a b d] is {0}",
        c1 >= c2);
    return (0);
    }

a b c
a b d
[a b c] >= [a b c] is True
[a b c] >= [a b d] is False