La classe `deque`

Article
10/12/2023

Organise les éléments d'un type en un arrangement linéaire et, comme un vecteur, permet un accès aléatoire rapide à n'importe quel élément, ainsi que l'insertion et la suppression efficace à l'arrière du conteneur. Cependant, contrairement à un vecteur, la classe deque prend également en charge l'insertion et la suppression efficace à l'avant du conteneur.

Syntaxe

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

Paramètres

Type
Type de données d'élément à stocker dans le deque.

Allocator
Type qui représente l’objet d’allocateur stocké qui encapsule des détails sur l’allocation et la désallocation de la dequemémoire. Cet argument est facultatif et sa valeur par défaut est allocator<Type>.

Notes

Le choix du type de conteneur doit être basé en général sur le type de la recherche et de l'insertion requis par l'application. Vectors doit être le conteneur préféré pour la gestion d’une séquence lorsque l’accès aléatoire à un élément se trouve à un niveau premium et que les insertions ou suppressions d’éléments ne sont requises qu’à la fin d’une séquence. Les performances du conteneur de liste sont meilleures quand des insertions et des suppressions efficaces (en temps constant) sont primordiales à n’importe quel emplacement de la séquence. Ces opérations au milieu de la séquence nécessitent des copies et des affectations d'éléments proportionnellement au nombre d'éléments de la séquence (délai linéaire).

Deque la réaffectation se produit lorsqu’une fonction membre doit insérer ou effacer des éléments de la séquence :

Si un élément est inséré dans une séquence vide ou si un élément est effacé pour quitter une séquence vide, les itérateurs précédemment retournés par begin et end deviennent non valides.
Si un élément est inséré à la première position du deque, tous les itérateurs, mais pas de références, qui désignent les éléments existants deviennent non valides.
Si un élément est inséré à la fin du deque, puis end tous les itérateurs, mais pas de références, qui désignent les éléments existants deviennent non valides.
Si un élément est effacé à l’avant du deque, seul cet itérateur et les références à l’élément effacé ne deviennent pas valides.
Si le dernier élément est effacé de la fin du deque, seul cet itérateur vers l’élément final et les références à l’élément effacé ne deviennent pas valides.

Dans le cas contraire, l'insertion ou la suppression d'un élément invalide tous les itérateurs et toutes les références.

Membres

Constructeurs

Nom Description

deque Construit un objet deque. Plusieurs constructeurs sont fournis pour configurer le contenu du nouveau deque de différentes manières : vide ; chargé avec un nombre spécifié d’éléments vides ; contenu déplacé ou copié à partir d’un autre deque; contenu copié ou déplacé à l’aide d’un itérateur ; et un élément copié dans les deque count temps. Certains constructeurs permettent l'utilisation d'un allocator personnalisé pour créer des éléments.

Nom	Description
`deque`	Construit un objet `deque`. Plusieurs constructeurs sont fournis pour configurer le contenu du nouveau `deque` de différentes manières : vide ; chargé avec un nombre spécifié d’éléments vides ; contenu déplacé ou copié à partir d’un autre `deque`; contenu copié ou déplacé à l’aide d’un itérateur ; et un élément copié dans les `deque` `count` temps. Certains constructeurs permettent l'utilisation d'un `allocator` personnalisé pour créer des éléments.

Typedefs

Nom	Description
`allocator_type`	Type qui représente la classe `allocator` pour l'objet `deque`.
`const_iterator`	Type qui fournit un itérateur à accès aléatoire qui peut accéder à et lire des éléments dans la `deque` en tant que `const`.
`const_pointer`	Type qui fournit un pointeur vers un élément dans un `deque` as `const`.
`const_reference`	Type qui fournit une référence à un élément d’un `deque` élément pour la lecture et d’autres opérations en tant que `const`.
`const_reverse_iterator`	Type qui fournit un itérateur à accès aléatoire qui peut accéder à et lire des éléments dans la `deque` en tant que `const`. La `deque` vue est inversée. Pour plus d’informations, consultez `reverse_iterator` Classe
`difference_type`	Type qui fournit la différence entre deux itérateurs à accès aléatoire qui référencent des éléments de la même `deque`.
`iterator`	Type qui fournit un itérateur à accès aléatoire qui peut lire ou modifier tout élément d'une `deque`.
`pointer`	Type qui fournit un pointeur vers un élément d'un objet `deque`.
`reference`	Type qui fournit une référence à un élément stocké dans un `deque`.
`reverse_iterator`	Type qui fournit un itérateur à accès aléatoire qui peut lire ou modifier un élément d'une `deque`. L’affichage `deque` est dans l’ordre inverse.
`size_type`	Type qui compte le nombre d'éléments d'une `deque`.
`value_type`	Type qui représente le type de données stocké dans un `deque`.

Functions

Nom	Description
`assign`	Efface les éléments d'une `deque` et copie une nouvelle séquence d'éléments vers la `deque` cible.
`at`	Retourne une référence à l'élément à un emplacement spécifié dans la `deque`.
`back`	Retourne une référence au dernier élément de la `deque`.
`begin`	Retourne un itérateur à accès aléatoire pointant vers le premier élément de la `deque`.
`cbegin`	Retourne un `const` itérateur au premier élément du `deque`.
`cend`	Retourne un itérateur `const` à accès aléatoire qui pointe juste après la fin de la `deque`.
`clear`	Efface tous les éléments d'un `deque`.
`crbegin`	Retourne un itérateur d’accès `const` aléatoire au premier élément d’une vue dans l’ordre `deque` inverse.
`crend`	Retourne un itérateur d’accès `const` aléatoire au premier élément d’une vue dans l’ordre `deque` inverse.
`emplace`	Insère un élément construit sur place à la position spécifiée dans la `deque`.
`emplace_back`	Ajoute un élément construit sur place à la fin de la `deque`.
`emplace_front`	Ajoute un élément construit sur place au début de la `deque`.
`empty`	Retourne `true` si la `deque` ne contient pas d'élément, et `false` si elle contient un ou plusieurs éléments.
`end`	Retourne un itérateur à accès aléatoire qui pointe juste après la fin de la `deque`.
`erase`	Supprime un élément ou une plage d'éléments aux positions spécifiées d'une `deque`.
`front`	Retourne une référence au premier élément d'une `deque`.
`get_allocator`	Retourne une copie de l'objet `allocator` qui est utilisé pour construire le `deque`.
`insert`	Insère un élément, plusieurs éléments ou une plage d'éléments dans la `deque` à une position spécifiée.
`max_size`	Retourne la longueur maximale possible de la `deque`.
`pop_back`	Efface l'élément à la fin de la `deque`.
`pop_front`	Efface l'élément au début de la `deque`.
`push_back`	Ajoute un élément à la fin de la `deque`.
`push_front`	Ajoute un élément au début de la `deque`.
`rbegin`	Retourne un itérateur à accès aléatoire vers le premier élément d'une `deque` inversée.
`rend`	Retourne un itérateur qui pointe juste après le dernier élément d'une `deque` inversée.
`resize`	Spécifie une nouvelle taille pour un objet `deque`.
`shrink_to_fit`	Ignore la capacité excédentaire.
`size`	Retourne le nombre d'éléments d'un `deque`.
`swap`	Échange les éléments de deux `deque`.

Opérateurs

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

`allocator_type`

Type qui représente la classe d’allocator pour l’objet deque .

typedef Allocator allocator_type;

Notes

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

Exemple

Consultez l’exemple pour get_allocator.

`assign`

Efface les éléments d’un deque jeu d’éléments et copie un nouvel ensemble d’éléments vers la cible deque.

template <class InputIterator>
void assign(
    InputIterator First,
    InputIterator Last);

void assign(
    size_type Count,
    const Type& Val);

void assign(initializer_list<Type> IList);

Paramètres

First
Position du premier élément de la plage d’éléments à copier à partir de l’argument deque.

Last
Position du premier élément au-delà de la plage d’éléments à copier à partir de l’argument deque.

Count
Nombre de copies d’un élément inséré dans le deque.

Val
Valeur de l'élément inséré dans le deque.

IList
En initializer_list cours d’insertion dans le deque.

Notes

Une fois les éléments existants dans la cible deque effacés, assign insère une plage spécifiée d’éléments de l’origine deque ou d’un autre deque élément dans la cible deque, ou insère des copies d’un nouvel élément d’une valeur spécifiée dans la cible deque.

Exemple

// deque_assign.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>
#include <initializer_list>

int main()
{
    using namespace std;
    deque <int> c1, c2;
    deque <int>::const_iterator cIter;

    c1.push_back(10);
    c1.push_back(20);
    c1.push_back(30);
    c2.push_back(40);
    c2.push_back(50);
    c2.push_back(60);

    deque<int> d1{ 1, 2, 3, 4 };
    initializer_list<int> iList{ 5, 6, 7, 8 };
    d1.assign(iList);

    cout << "d1 = ";
    for (int i : d1)
        cout << i;
    cout << endl;

    cout << "c1 =";
    for (int i : c1)
        cout << i;
    cout << endl;

    c1.assign(++c2.begin(), c2.end());
    cout << "c1 =";
    for (int i : c1)
        cout << i;
    cout << endl;

    c1.assign(7, 4);
    cout << "c1 =";
    for (int i : c1)
        cout << i;
    cout << endl;
}

d1 = 5678c1 =102030c1 =5060c1 =4444444

`at`

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

reference at(size_type pos);

const_reference at(size_type pos) const;

Paramètres

pos
Indice (ou numéro de position) de l’élément à référencer dans le deque.

Valeur de retour

Si pos elle est supérieure à la taille du deque, at lève une exception.

Notes

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

Exemple

// deque_at.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;

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

   const int& i = c1.at( 0 );
   int& j = c1.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 de la deque.

reference back();
const_reference back() const;

Valeur de retour

Dernier élément du deque. Si la deque valeur est vide, la valeur de retour n’est pas définie.

Notes

Si la valeur de retour d’un back objet est affectée à un const_reference, l’objet deque ne peut pas être modifié. Si la valeur de retour d’un back objet est affectée à un reference, l’objet deque 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 élément vide deque. Consultez Itérateurs vérifiés pour plus d’informations.

Exemple

// deque_back.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;

   c1.push_back( 10 );
   c1.push_back( 11 );

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

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

The last integer of c1 is 11
The next-to-last integer of c1 is 10

`begin`

Retourne un itérateur traitant le premier élément d'un deque.

const_iterator begin() const;
iterator begin();

Valeur de retour

Itérateur à accès aléatoire qui traite le premier élément dans l’objet deque ou l’emplacement suivant un objet deque vide.

Notes

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

Exemple

// deque_begin.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

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

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

   c1_Iter = c1.begin( );
   cout << "The first element of c1 is " << *c1_Iter << endl;

*c1_Iter = 20;
   c1_Iter = c1.begin( );
   cout << "The first element of c1 is now " << *c1_Iter << endl;

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

The first element of c1 is 1
The first element of c1 is now 20

`cbegin`

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

const_iterator cbegin() const;

Valeur de retour

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é conjointement 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 itérateur const qui traite l'emplacement situé immédiatement après le dernier élément d'une plage.

const_iterator cend() const;

Valeur de retour

Itérateur d'accès aléatoire qui pointe juste après la fin de la plage.

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é conjointement 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 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.

`clear`

Efface tous les éléments d'un deque.

void clear();

Exemple

// deque_clear.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;

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

   cout << "The size of the deque is initially " << c1.size( ) << endl;
   c1.clear( );
   cout << "The size of the deque after clearing is " << c1.size( ) << endl;
}

The size of the deque is initially 3
The size of the deque after clearing is 0

`const_iterator`

Type qui fournit un itérateur d’accès aléatoire qui peut accéder et lire un const élément dans le deque.

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 pour back.

`const_pointer`

Fournit un pointeur vers un const élément dans un deque.

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 iterator élément est plus couramment utilisé pour accéder à un deque élément.

`const_reference`

Type qui fournit une référence à un élément const stocké dans un deque pour la lecture et l'exécution des opérations const.

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

// deque_const_ref.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;

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

   const deque <int> c2 = c1;
   const int &i = c2.front( );
   const int &j = c2.back( );
   cout << "The first element is " << i << endl;
   cout << "The second element is " << j << endl;

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

The first element is 10
The second element is 20

`const_reverse_iterator`

Type qui fournit un itérateur d’accès aléatoire qui peut lire n’importe quel const élément dans le deque.

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 l’inverse deque .

Exemple

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

`crbegin`

Retourne un const itérateur au premier élément d’un élément inversé deque.

const_reverse_iterator crbegin() const;

Valeur de retour

Itérateur const d’accès aléatoire inverse qui traite le premier élément d’un élément inversé deque ou qui a traité ce qui avait été le dernier élément dans l’élément non inversé deque.

Notes

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

Exemple

// deque_crbegin.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

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

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

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

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

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

`crend`

Retourne un const itérateur qui traite l’emplacement qui réussit le dernier élément d’un élément inversé deque.

const_reverse_iterator crend() const;

Valeur de retour

Itérateur const d’accès aléatoire inverse qui traite l’emplacement qui réussit le dernier élément d’un inverse (l’emplacement qui avait précédé le premier élément dans l’élément non dequeinversé deque ).

Notes

crend est utilisé avec un inverse deque comme array::cend utilisé avec un deque.

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

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

La valeur retournée par crend ne doit pas être déréférencement.

Exemple

// deque_crend.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> v1;
   deque <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

`deque`

Construit une deque taille spécifique, ou avec des éléments d’une valeur spécifique, ou avec un allocateur spécifique, ou en tant que copie de tout ou partie d’une autre dequevaleur .

deque();

explicit deque(const Allocator& Al);
explicit deque(size_type Count);
deque(size_type Count, const Type& Val);

deque(
    size_type Count,
    const Type& Val,
    const Allocator& Al);

deque(const deque& Right);

template <class InputIterator>
deque(InputIterator First,  InputIterator Last);

template <class InputIterator>
deque(
   InputIterator First,
   InputIterator Last,
   const Allocator& Al);

deque(initializer_list<value_type> IList, const Allocator& Al);

Paramètres

Al
Classe allocator à utiliser avec cet objet.

Count
Nombre d’éléments dans la construction deque.

Val
Valeur des éléments dans la construction deque.

Right
deque dont le deque 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.

IList
initializer_list à copier.

Notes

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

Les deux premiers constructeurs spécifient un initial dequevide ; le deuxième spécifie également le type d’allocator (_Al) à 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 val.

Le sixième constructeur spécifie une copie du deque Right.

Les septième et huitième constructeurs copient la plage [First, Last) d’un deque.

Le septième constructeur déplace le deque Right.

Le huitième constructeur copie le contenu d’un initializer_list.

Aucun des constructeurs n'effectue de réallocations temporaires.

Exemple

/ compile with: /EHsc
#include <deque>
#include <iostream>
#include <forward_list>

int main()
{
    using namespace std;

    forward_list<int> f1{ 1, 2, 3, 4 };

    f1.insert_after(f1.begin(), { 5, 6, 7, 8 });

    deque <int>::iterator c1_Iter, c2_Iter, c3_Iter, c4_Iter, c5_Iter, c6_Iter;

    // Create an empty deque c0
    deque <int> c0;

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

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

    // Create a deque c3 with 3 elements of value 1 and with the
    // allocator of deque c2
    deque <int> c3(3, 1, c2.get_allocator());

    // Create a copy, deque c4, of deque c2
    deque <int> c4(c2);

    // Create a deque c5 by copying the range c4[ first,  last)
    c4_Iter = c4.begin();
    c4_Iter++;
    c4_Iter++;
    deque <int> c5(c4.begin(), c4_Iter);

    // Create a deque c6 by copying the range c4[ first,  last) and
    // c2 with the allocator of deque
    c4_Iter = c4.begin();
    c4_Iter++;
    c4_Iter++;
    c4_Iter++;
    deque <int> c6(c4.begin(), c4_Iter, c2.get_allocator());

    // Create a deque c8 by copying the contents of an initializer_list
    // using brace initialization
    deque<int> c8({ 1, 2, 3, 4 });

    initializer_list<int> iList{ 5, 6, 7, 8 };
    deque<int> c9( iList);

    cout << "c1 = ";
    for (int i : c1)
        cout << i << " ";
    cout << endl;

    cout << "c2 = ";
    for (int i : c2)
        cout << i << " ";
    cout << endl;

    cout << "c3 = ";
    for (int i : c3)
        cout << i << " ";
    cout << endl;

    cout << "c4 = ";
    for (int i : c4)
        cout << i << " ";
    cout << endl;

    cout << "c5 = ";
    for (int i : c5)
        cout << i << " ";
    cout << endl;

    cout << "c6 = ";
    for (int i : c6)
        cout << i << " ";
    cout << endl;

    // Move deque c6 to deque c7
    deque <int> c7(move(c6));
    deque <int>::iterator c7_Iter;

    cout << "c7 =";
    for (int i : c7)
        cout << i << " ";
    cout << endl;

    cout << "c8 = ";
    for (int i : c8)
        cout << i << " ";
    cout << endl;

    cout << "c9 = ";
    for (int i : c9)
        cout << i << " ";
    cout << endl;

    int x = 3;
}
// deque_deque.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
    using namespace std;
   deque <int>::iterator c1_Iter, c2_Iter, c3_Iter, c4_Iter, c5_Iter, c6_Iter;

    // Create an empty deque c0
    deque <int> c0;

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

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

    // Create a deque c3 with 3 elements of value 1 and with the
    // allocator of deque c2
    deque <int> c3( 3, 1, c2.get_allocator( ) );

    // Create a copy, deque c4, of deque c2
    deque <int> c4( c2 );

    // Create a deque c5 by copying the range c4[ first,  last)
    c4_Iter = c4.begin( );
    c4_Iter++;
    c4_Iter++;
    deque <int> c5( c4.begin( ), c4_Iter );

    // Create a deque c6 by copying the range c4[ first,  last) and
    // c2 with the allocator of deque
    c4_Iter = c4.begin( );
   c4_Iter++;
   c4_Iter++;
   c4_Iter++;
   deque <int> c6( c4.begin( ), c4_Iter, c2.get_allocator( ) );

    // Create a deque c8 by copying the contents of an initializer_list
    // using brace initialization
    deque<int> c8({ 1, 2, 3, 4 });

        initializer_list<int> iList{ 5, 6, 7, 8 };
    deque<int> c9( iList);

    cout << "c1 = ";
    for ( c1_Iter = c1.begin( ); c1_Iter != c1.end( ); c1_Iter++ )
        cout << *c1_Iter << " ";
    cout << endl;

    cout << "c2 = ";
    for ( c2_Iter = c2.begin( ); c2_Iter != c2.end( ); c2_Iter++ )
        cout << *c2_Iter << " ";
    cout << endl;

    cout << "c3 = ";
    for ( c3_Iter = c3.begin( ); c3_Iter != c3.end( ); c3_Iter++ )
        cout << *c3_Iter << " ";
    cout << endl;

    cout << "c4 = ";
    for ( c4_Iter = c4.begin( ); c4_Iter != c4.end( ); c4_Iter++ )
        cout << *c4_Iter << " ";
    cout << endl;

    cout << "c5 = ";
    for ( c5_Iter = c5.begin( ); c5_Iter != c5.end( ); c5_Iter++ )
        cout << *c5_Iter << " ";
    cout << endl;

    cout << "c6 = ";
    for ( c6_Iter = c6.begin( ); c6_Iter != c6.end( ); c6_Iter++ )
        cout << *c6_Iter << " ";
    cout << endl;

    // Move deque c6 to deque c7
    deque <int> c7( move(c6) );
    deque <int>::iterator c7_Iter;

    cout << "c7 =" ;
    for ( c7_Iter = c7.begin( ) ; c7_Iter != c7.end( ) ; c7_Iter++ )
        cout << " " << *c7_Iter;
    cout << endl;

    cout << "c8 = ";
    for (int i : c8)
        cout << i << " ";
    cout << endl;

    cout << "c9 = ";
    or (int i : c9)
        cout << i << " ";
    cout << endl;
}

`difference_type`

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

typedef typename Allocator::difference_type difference_type;

Notes

Un difference_type peut également représenter le nombre d'éléments entre deux pointeurs.

Exemple

// deque_diff_type.cpp
// compile with: /EHsc
#include <iostream>
#include <deque>
#include <algorithm>

int main( )
{
   using namespace std;

   deque <int> c1;
   deque <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( );

   deque <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 la deque.

iterator emplace(
    const_iterator _Where,
    Type&& val);

Paramètres

_Where
Position dans l’emplacement deque où le premier élément est inséré.

val
Valeur de l'élément inséré dans le deque.

Valeur de retour

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

Notes

Une opération d’insertion peut s’avérer coûteuse. Consultez deque pour en savoir plus sur les performances de deque.

Exemple

// deque_emplace.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> v1;
   deque <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 deque of deques by moving v1
   deque < deque <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 de la deque.

void emplace_back(Type&& val);

Paramètres

val
Élément ajouté à la fin de l'objet deque.

Exemple

// deque_emplace_back.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

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

   v1.push_back( 1 );
   if ( v1.size( ) != 0 )
      cout << "Last element: " << v1.back( ) << endl;

   v1.push_back( 2 );
   if ( v1.size( ) != 0 )
      cout << "New last element: " << v1.back( ) << endl;

// initialize a deque of deques by moving v1
   deque < deque <int> > vv1;

   vv1.emplace_back( move( v1 ) );
   if ( vv1.size( ) != 0 && vv1[0].size( ) != 0 )
      cout << "Moved last element: " << vv1[0].back( ) << endl;
}

Last element: 1
New last element: 2
Moved last element: 2

`emplace_front`

Ajoute un élément construit sur place à la fin de la deque.

void emplace_front(Type&& val);

Paramètres

val
Élément ajouté au début du deque.

Exemple

// deque_emplace_front.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

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

   v1.push_back( 1 );
   if ( v1.size( ) != 0 )
      cout << "Last element: " << v1.back( ) << endl;

   v1.push_back( 2 );
   if ( v1.size( ) != 0 )
      cout << "New last element: " << v1.back( ) << endl;

// initialize a deque of deques by moving v1
   deque < deque <int> > vv1;

   vv1.emplace_front( move( v1 ) );
   if ( vv1.size( ) != 0 && vv1[0].size( ) != 0 )
      cout << "Moved last element: " << vv1[0].back( ) << endl;
}

Last element: 1
New last element: 2
Moved last element: 2

`empty`

Vérifie si un deque est vide.

bool empty() const;

Valeur de retour

true s’il deque est vide ; false s’il deque n’est pas vide.

Exemple

// deque_empty.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;

   c1.push_back( 10 );
   if ( c1.empty( ) )
      cout << "The deque is empty." << endl;
   else
      cout << "The deque is not empty." << endl;
}

The deque is not empty.

`end`

Retourne un itérateur qui traite l'emplacement suivant le dernier élément d'un deque.

const_iterator end() const;

iterator end();

Valeur de retour

Itérateur d’accès aléatoire qui traite l’emplacement qui réussit le dernier élément d’un deque. Si le deque est vide, deque::end == deque::begin.

Notes

end est utilisé pour déterminer si un itérateur a atteint la fin de son deque.

Exemple

// deque_end.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;
   deque <int>::iterator c1_Iter;

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

   c1_Iter = c1.end( );
   c1_Iter--;
   cout << "The last integer of c1 is " << *c1_Iter << endl;

   c1_Iter--;
   *c1_Iter = 400;
   cout << "The new next-to-last integer of c1 is " << *c1_Iter << endl;

   // If a const iterator had been declared instead with the line:
   // deque <int>::const_iterator c1_Iter;
   // an error would have resulted when inserting the 400

   cout << "The deque is now:";
   for ( c1_Iter = c1.begin( ); c1_Iter != c1.end( ); c1_Iter++ )
      cout << " " << *c1_Iter;
}

The last integer of c1 is 30
The new next-to-last integer of c1 is 400
The deque is now: 10 400 30

`erase`

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

iterator erase(iterator _Where);

iterator erase(iterator first, iterator last);

Paramètres

_Where
Position de l’élément à supprimer du deque.

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

last
Position juste au-delà du dernier élément supprimé du deque.

Valeur de retour

Itérateur d’accès aléatoire qui désigne le premier élément restant au-delà des éléments supprimés, ou un pointeur vers la fin du deque cas où aucun élément de ce type n’existe.

Notes

erase ne lève jamais d’exception.

Exemple

// deque_erase.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;
   deque <int>::iterator Iter;

   c1.push_back( 10 );
   c1.push_back( 20 );
   c1.push_back( 30 );
   c1.push_back( 40 );
   c1.push_back( 50 );
   cout << "The initial deque is: ";
   for ( Iter = c1.begin( ); Iter != c1.end( ); Iter++ )
      cout << *Iter << " ";
   cout << endl;
   c1.erase( c1.begin( ) );
   cout << "After erasing the first element, the deque becomes:  ";
   for ( Iter = c1.begin( ); Iter != c1.end( ); Iter++ )
      cout << *Iter << " ";
   cout << endl;
   Iter = c1.begin( );
   Iter++;
   c1.erase( Iter, c1.end( ) );
   cout << "After erasing all elements but the first, deque becomes: ";
   for ( Iter = c1.begin( ); Iter != c1.end( ); Iter++ )
      cout << *Iter << " ";
   cout << endl;
}

The initial deque is: 10 20 30 40 50
After erasing the first element, the deque becomes:  20 30 40 50
After erasing all elements but the first, deque becomes: 20

`front`

Retourne une référence au premier élément d'une deque.

reference front();

const_reference front() const;

Valeur de retour

Si la deque valeur est vide, le retour n’est pas défini.

Notes

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

Exemple

// deque_front.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;

   c1.push_back( 10 );
   c1.push_back( 11 );

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

   cout << "The first integer of c1 is " << i << endl;
   i++;
   cout << "The second integer of c1 is " << ii << endl;
}

The first integer of c1 is 10
The second integer of c1 is 11

`get_allocator`

Retourne une copie de l’objet allocator utilisé pour construire le deque.

Allocator get_allocator() const;

Valeur de retour

Allocator utilisé par le deque.

Notes

Les allocateurs de la deque classe 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 font l'objet d'une rubrique avancée du langage C++.

Exemple

// deque_get_allocator.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

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

   // c3 will use the same allocator class as c1
   deque <int> c3( c1.get_allocator( ) );

   deque <int>::allocator_type xlst = c1.get_allocator( );
   // You can now call functions on the allocator class used by c1
}

`insert`

Insère un élément ou un certain nombre d’éléments ou une plage d’éléments dans la deque position spécifiée.

iterator insert(
    const_iterator Where,
    const Type& Val);

iterator insert(
    const_iterator Where,
    Type&& Val);

void insert(
    iterator Where,
    size_type Count,
    const Type& Val);

template <class InputIterator>
void insert(
    iterator Where,
    InputIterator First,
    InputIterator Last);

iterator insert(
    iterator Where,initializer_list<Type>
IList);

Paramètres

Where
Position dans la cible deque où le premier élément est inséré.

Val
Valeur de l'élément inséré dans le deque.

Count
Nombre d’éléments insérés dans le deque.

First
Position du premier élément de la plage d’éléments dans l’argument deque à copier.

Last
Position du premier élément au-delà de la plage d’éléments dans l’argument deque à copier.

IList
initializer_list Éléments à insérer.

Valeur de retour

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

Notes

Une opération d’insertion peut être coûteuse.

`iterator`

Type qui fournit un itérateur à accès aléatoire qui peut lire ou modifier tout élément d'une deque.

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 du deque.

size_type max_size() const;

Valeur de retour

Longueur maximale possible du deque.

Exemple

// deque_max_size.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;
   deque <int>::size_type i;

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

`operator[]`

Retourne une référence à l'élément d'un objet deque à une position spécifiée.

reference operator[](size_type pos);

const_reference operator[](size_type pos) const;

Paramètres

pos
Position de l’élément deque à référencer.

Valeur de retour

Référence à l’élément dont la position est spécifiée dans l’argument. Si la position spécifiée est supérieure à la taille du deque, le résultat n’est pas défini.

Notes

Si la valeur de retour d’un operator[] objet est affectée à un const_reference, l’objet deque ne peut pas être modifié. Si la valeur de retour d’un operator[] objet est affectée à un reference, l’objet deque 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 deque. Consultez Itérateurs vérifiés pour plus d’informations.

Exemple

// deque_op_ref.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;

   c1.push_back( 10 );
   c1.push_back( 20 );
   cout << "The first integer of c1 is " << c1[0] << endl;
   int& i = c1[1];
   cout << "The second integer of c1 is " << i << endl;
}

The first integer of c1 is 10
The second integer of c1 is 20

`operator=`

Remplace les éléments de cette opération deque à l’aide des éléments d’un autre deque.

deque& operator=(const deque& right);

deque& operator=(deque&& right);

Paramètres

right
Qui deque fournit le nouveau contenu.

Notes

Le premier remplacement copie les éléments à partir de right: deque la source de l’affectation. Le deuxième remplacement déplace les éléments vers ceci deque depuis right.

Les éléments contenus dans ce deque contenu avant l’exécution de l’opérateur sont supprimés.

Exemple

// deque_operator_as.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>
using namespace std;

typedef deque<int> MyDeque;

template<typename MyDeque> struct S;

template<typename MyDeque> struct S<MyDeque&> {
  static void show( MyDeque& d ) {
    MyDeque::const_iterator iter;
    for (iter = d.cbegin(); iter != d.cend(); iter++)
       cout << *iter << " ";
    cout << endl;
  }
};

template<typename MyDeque> struct S<MyDeque&&> {
  static void show( MyDeque&& d ) {
    MyDeque::const_iterator iter;
    for (iter = d.cbegin(); iter != d.cend(); iter++)
       cout << *iter << " ";
cout << " via unnamed rvalue reference " << endl;
  }
};

int main( )
{
   MyDeque d1, d2;

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

   cout << "d1 = " ;
   S<MyDeque&>::show( d1 );

   d2 = d1;
   cout << "d2 = ";
   S<MyDeque&>::show( d2 );

   cout << "     ";
   S<MyDeque&&>::show ( move< MyDeque& > (d1) );
}

`pointer`

Fournit un pointeur vers un élément dans un deque.

typedef typename Allocator::pointer pointer;

Notes

Un type pointer peut être utilisé pour modifier la valeur d’un élément. Un iterator élément est plus couramment utilisé pour accéder à un deque élément.

`pop_back`

Supprime l’élément à la fin du deque.

void pop_back();

Notes

Le dernier élément ne doit pas être vide. pop_back ne lève jamais d’exception.

Exemple

// deque_pop_back.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;

   c1.push_back( 1 );
   c1.push_back( 2 );
   cout << "The first element is: " << c1.front( ) << endl;
   cout << "The last element is: " << c1.back( ) << endl;

   c1.pop_back( );
   cout << "After deleting the element at the end of the deque, the "
      "last element is: " << c1.back( ) << endl;
}

The first element is: 1
The last element is: 2
After deleting the element at the end of the deque, the last element is: 1

`pop_front`

Supprime l’élément au début du deque.

void pop_front();

Notes

Le premier élément ne doit pas être vide. pop_front ne lève jamais d’exception.

Exemple

// deque_pop_front.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;

   c1.push_back( 1 );
   c1.push_back( 2 );
   cout << "The first element is: " << c1.front( ) << endl;
   cout << "The second element is: " << c1.back( ) << endl;

   c1.pop_front( );
   cout << "After deleting the element at the beginning of the "
      "deque, the first element is: " << c1.front( ) << endl;
}

The first element is: 1
The second element is: 2
After deleting the element at the beginning of the `deque`, the first element is: 2

`push_back`

Ajoute un élément à la fin de la deque.

void push_back(const Type& val);

void push_back(Type&& val);

Paramètres

val
Élément ajouté à la fin de l'objet deque.

Notes

Si une exception est levée, l'objet deque n'est pas modifié et l'exception est levée de nouveau.

`push_front`

Ajoute un élément au début du deque.

void push_front(const Type& val);
void push_front(Type&& val);

Paramètres

val
Élément ajouté au début du deque.

Notes

Si une exception est levée, l'objet deque n'est pas modifié et l'exception est levée de nouveau.

Exemple

// deque_push_front.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>
#include <string>

int main( )
{
   using namespace std;
   deque <int> c1;

   c1.push_front( 1 );
   if ( c1.size( ) != 0 )
      cout << "First element: " << c1.front( ) << endl;

   c1.push_front( 2 );
   if ( c1.size( ) != 0 )
      cout << "New first element: " << c1.front( ) << endl;

// move initialize a deque of strings
   deque <string> c2;
   string str("a");

   c2.push_front( move( str ) );
   cout << "Moved first element: " << c2.front( ) << endl;
}

First element: 1
New first element: 2
Moved first element: a

`rbegin`

Retourne un itérateur au premier élément d’un élément inversé deque.

const_reverse_iterator rbegin() const;

reverse_iterator rbegin();

Valeur de retour

Itérateur d’accès aléatoire inverse qui traite le premier élément d’un élément inversé deque ou qui a traité ce qui avait été le dernier élément dans l’élément non inversé deque.

Notes

rbegin est utilisé avec un inverse deque comme begin utilisé avec un deque.

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

Vous pouvez utiliser rbegin pour itérer un objet deque vers l’arrière.

Exemple

// deque_rbegin.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;
   deque <int>::iterator c1_Iter;
   deque <int>::reverse_iterator c1_rIter;

   // If the following line had replaced the line above, an error
   // would have resulted in the line modifying an element
   // (commented below) because the iterator would have been const
   // deque <int>::const_reverse_iterator c1_rIter;

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

   c1_rIter = c1.rbegin( );
   cout << "Last element in the deque is " << *c1_rIter << "." << endl;

   cout << "The deque contains the elements: ";
   for ( c1_Iter = c1.begin( ); c1_Iter != c1.end( ); c1_Iter++ )
      cout << *c1_Iter << " ";
   cout << "in that order.";
   cout << endl;

   // rbegin can be used to iterate through a deque in reverse order
   cout << "The reversed deque is: ";
   for ( c1_rIter = c1.rbegin( ); c1_rIter != c1.rend( ); c1_rIter++ )
      cout << *c1_rIter << " ";
   cout << endl;

   c1_rIter = c1.rbegin( );
   *c1_rIter = 40;  // This would have caused an error if a
                    // const_reverse iterator had been declared as
                    // noted above
   cout << "Last element in deque is now " << *c1_rIter << "." << endl;
}

Last element in the deque is 30.
The deque contains the elements: 10 20 30 in that order.
The reversed deque is: 30 20 10
Last element in deque is now 40.

`reference`

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

typedef typename Allocator::reference reference;

Exemple

// deque_reference.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;

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

   const int &i = c1.front( );
   int &j = c1.back( );
   cout << "The first element is " << i << endl;
   cout << "The second element is " << j << endl;
}

The first element is 10
The second element is 20

`rend`

Retourne un itérateur qui traite l'emplacement suivant le dernier élément d'un deque inversé.

const_reverse_iterator rend() const;

reverse_iterator rend();

Valeur de retour

Itérateur d’accès aléatoire inverse qui traite l’emplacement qui réussit le dernier élément d’un inverse (l’emplacement qui avait précédé le premier élément dans l’élément non dequeinversé deque ).

Notes

rend est utilisé avec un inverse deque comme end utilisé avec un deque.

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

rend peut être utilisé pour tester si un itérateur inverse a atteint la fin de son deque.

La valeur retournée par rend ne doit pas être déréférencement.

Exemple

// deque_rend.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;

   deque <int> c1;
   deque <int>::iterator c1_Iter;
   deque <int>::reverse_iterator c1_rIter;
   // If the following line had replaced the line above, an error
   // would have resulted in the line modifying an element
   // (commented below) because the iterator would have been const
   // deque <int>::const_reverse_iterator c1_rIter;

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

   c1_rIter = c1.rend( );
   c1_rIter --; // Decrementing a reverse iterator moves it forward
                // in the deque (to point to the first element here)
   cout << "The first element in the deque is: " << *c1_rIter << endl;

   cout << "The deque is: ";
   for ( c1_Iter = c1.begin( ); c1_Iter != c1.end( ); c1_Iter++ )
      cout << *c1_Iter << " ";
   cout << endl;

   // rend can be used to test if an iteration is through all of
   // the elements of a reversed deque
   cout << "The reversed deque is: ";
   for ( c1_rIter = c1.rbegin( ); c1_rIter != c1.rend( ); c1_rIter++ )
      cout << *c1_rIter << " ";
   cout << endl;

   c1_rIter = c1.rend( );
   c1_rIter--; // Decrementing the reverse iterator moves it backward
               // in the reversed deque (to the last element here)
   *c1_rIter = 40; // This modification of the last element would
                   // have caused an error if a const_reverse
                   // iterator had been declared (as noted above)
   cout << "The modified reversed deque is: ";
   for ( c1_rIter = c1.rbegin( ); c1_rIter != c1.rend( ); c1_rIter++ )
      cout << *c1_rIter << " ";
   cout << endl;
}

The first element in the deque is: 10
The deque is: 10 20 30
The reversed deque is: 30 20 10
The modified reversed deque is: 30 20 40

`resize`

Spécifie une nouvelle taille pour un objet deque.

void resize(size_type _Newsize);

void resize(size_type _Newsize, Type val);

Paramètres

_Newsize
Nouvelle taille du deque.

val
Valeur des nouveaux éléments à ajouter au si la nouvelle taille est supérieure à deque la taille d’origine. Si la valeur est omise, la valeur par défaut pour la classe est assignée aux nouveaux éléments.

Notes

Si les dequeéléments size sont inférieurs à , les éléments sont ajoutés _Newsizeà la deque taille jusqu’à ce qu’ils atteignent la taille _Newsize.

Si le deque's size est supérieur _Newsizeà , les éléments les plus proches de la fin de l’objet deque sont supprimés jusqu’à atteindre la deque taille _Newsize.

Si la taille actuelle du fichier deque est identique _Newsizeà , aucune action n’est effectuée.

size reflète la taille actuelle du deque.

Exemple

// deque_resize.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;

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

   c1.resize( 4,40 );
   cout << "The size of c1 is: " << c1.size( ) << endl;
   cout << "The value of the last element is " << c1.back( ) << endl;

   c1.resize( 5 );
   cout << "The size of c1 is now: " << c1.size( ) << endl;
   cout << "The value of the last element is now " << c1.back( ) << endl;

   c1.resize( 2 );
   cout << "The reduced size of c1 is: " << c1.size( ) << endl;
   cout << "The value of the last element is now " << c1.back( ) << endl;
}

The size of c1 is: 4
The value of the last element is 40
The size of c1 is now: 5
The value of the last element is now 0
The reduced size of c1 is: 2
The value of the last element is now 20

`reverse_iterator`

Type qui fournit un itérateur d’accès aléatoire qui peut lire ou modifier un élément dans un élément inversé deque.

typedef std::reverse_iterator<iterator> reverse_iterator;

Notes

Un type reverse_iterator est utilisé pour itérer au sein du deque.

Exemple

Consultez l’exemple relatif à rbegin.

`shrink_to_fit`

Ignore la capacité excédentaire.

void shrink_to_fit();

Notes

Il n’existe aucun moyen portable de déterminer si shrink_to_fit le stockage utilisé par un deque.

Exemple

// deque_shrink_to_fit.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

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

   v1.push_back( 1 );
   v1.push_back( 2 );
   cout << "Current size of v1 = "
      << v1.size( ) << endl;
   v1.shrink_to_fit();
   cout << "Current size of v1 = "
      << v1.size( ) << endl;
}

Current size of v1 = 1
Current size of v1 = 1

`size`

Retourne le nombre d'éléments d'un deque.

size_type size() const;

Valeur de retour

Longueur actuelle du deque.

Exemple

// deque_size.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;
   deque <int>::size_type i;

   c1.push_back( 1 );
   i = c1.size( );
   cout << "The deque length is " << i << "." << endl;

   c1.push_back( 2 );
   i = c1.size( );
   cout << "The deque length is now " << i << "." << endl;
}

The deque length is 1.
The deque length is now 2.

`size_type`

Type qui compte le nombre d'éléments d'une deque.

typedef typename Allocator::size_type size_type;

Exemple

Consultez l’exemple pour size.

`swap`

Échange les éléments de deux classes deque.

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

friend void swap(deque<Type, Allocator>& left, deque<Type, Allocator>& right) template <class Type, class Allocator>
void swap(deque<Type, Allocator>& left, deque<Type, Allocator>& right);

Paramètres

right
Le deque fait de fournir les éléments à permuter, ou les deque éléments dont les éléments doivent être échangés avec ceux du deque left.

left
Dont deque les éléments doivent être échangés avec ceux du deque right.

Exemple

// deque_swap.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1, c2, c3;
   deque <int>::iterator c1_Iter;

   c1.push_back( 1 );
   c1.push_back( 2 );
   c1.push_back( 3 );
   c2.push_back( 10 );
   c2.push_back( 20 );
   c3.push_back( 100 );

   cout << "The original deque c1 is:";
   for ( c1_Iter = c1.begin( ); c1_Iter != c1.end( ); c1_Iter++ )
      cout << " " << *c1_Iter;
   cout << endl;

   c1.swap( c2 );

   cout << "After swapping with c2, deque c1 is:";
   for ( c1_Iter = c1.begin( ); c1_Iter != c1.end( ); c1_Iter++ )
      cout << " " << *c1_Iter;
   cout << endl;

   swap( c1,c3 );

   cout << "After swapping with c3, deque c1 is:";
   for ( c1_Iter = c1.begin( ); c1_Iter != c1.end( ); c1_Iter++ )
      cout << " " << *c1_Iter;
   cout << endl;

   swap<>(c1, c2);
   cout << "After swapping with c2, deque c1 is:";
   for ( c1_Iter = c1.begin( ); c1_Iter != c1.end( ); c1_Iter++ )
      cout << " " << *c1_Iter;
   cout << endl;
}

The original deque c1 is: 1 2 3
After swapping with c2, deque c1 is: 10 20
After swapping with c3, deque c1 is: 100
After swapping with c2, deque c1 is: 1 2 3

`value_type`

Type qui représente le type de données stocké dans un deque.

typedef typename Allocator::value_type value_type;

Notes

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

Exemple

// deque_value_type.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>
int main( )
{
   using namespace std;
   deque<int>::value_type AnInt;
   AnInt = 44;
   cout << AnInt << endl;
}

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

La classe deque

Syntaxe

Paramètres

Notes

Membres

Constructeurs

Typedefs

Functions

Opérateurs

allocator_type

Notes

Exemple

assign

Paramètres

Notes

Exemple

at

Paramètres

Valeur de retour

Notes

Exemple

back

Valeur de retour

Notes

Exemple

begin

Valeur de retour

Notes

Exemple

cbegin

Valeur de retour

Notes

cend

Valeur de retour

Notes

clear

Exemple

const_iterator

Notes

Exemple

const_pointer

Notes

const_reference

Notes

Exemple

const_reverse_iterator

Notes

Exemple

crbegin

Valeur de retour

Notes

Exemple

crend

Valeur de retour

Notes

Exemple

deque

Paramètres

Notes

Exemple

difference_type

Notes

Exemple

emplace

Paramètres

Valeur de retour

Notes

Exemple

emplace_back

Paramètres

Exemple

emplace_front

Paramètres

Exemple

empty

Valeur de retour

Exemple

end

Valeur de retour

La classe `deque`

`allocator_type`

`assign`

`at`

`back`

`begin`

`cbegin`

`cend`

`clear`

`const_iterator`

`const_pointer`

`const_reference`

`const_reverse_iterator`

`crbegin`

`crend`

`deque`

`difference_type`

`emplace`

`emplace_back`

`emplace_front`

`empty`

`end`

`erase`

`front`

`get_allocator`

`insert`

`iterator`

`max_size`

`operator[]`

`operator=`

`pointer`

`pop_back`

`pop_front`

`push_back`

`push_front`

`rbegin`

`reference`

`rend`

`resize`

`reverse_iterator`

`shrink_to_fit`