Namespaces
Variants

std:: deque

From cppreference.net
Défini dans l'en-tête <deque>
template <

class T,
class Allocator = std:: allocator < T >

> class deque ;
(1)
namespace pmr {

template < class T >
using deque = std :: deque < T, std:: pmr :: polymorphic_allocator < T >> ;

}
(2) (depuis C++17)

std::deque (double-ended queue) est une séquence indexée qui permet des insertions et suppressions rapides à son début et à sa fin. De plus, l'insertion et la suppression à chaque extrémité d'un deque n'invalident jamais les pointeurs ou références vers les autres éléments.

Contrairement au std::vector , les éléments d'un deque ne sont pas stockés de manière contiguë : les implémentations typiques utilisent une séquence de tableaux de taille fixe alloués individuellement, avec une comptabilité supplémentaire, ce qui signifie que l'accès indexé à un deque doit effectuer deux déréférencements de pointeur, comparé à l'accès indexé du vector qui n'en effectue qu'un.

Le stockage d'un deque est automatiquement étendu et réduit selon les besoins. L'extension d'un deque est moins coûteuse que l'extension d'un std::vector car elle n'implique pas la copie des éléments existants vers un nouvel emplacement mémoire. En revanche, les deques ont généralement un coût mémoire minimal important ; un deque contenant un seul élément doit allouer son tableau interne complet (par exemple 8 fois la taille de l'objet sur libstdc++ 64 bits ; 16 fois la taille de l'objet ou 4096 octets, selon la valeur la plus grande, sur libc++ 64 bits).

La complexité (efficacité) des opérations courantes sur les deques est la suivante :

  • Accès aléatoire - constant O(1) .
  • Insertion ou suppression d'éléments à la fin ou au début - constant O(1) .
  • Insertion ou suppression d'éléments - linéaire O(n) .

std::deque satisfait aux exigences de Container , AllocatorAwareContainer , SequenceContainer et ReversibleContainer .

Toutes les fonctions membres de std::deque sont constexpr : il est possible de créer et d'utiliser des objets std::deque lors de l'évaluation d'une expression constante.

Cependant, les objets std::deque ne peuvent généralement pas être constexpr , car toute mémoire allouée dynamiquement doit être libérée lors de la même évaluation d'expression constante.

(depuis C++26)

Table des matières

Paramètres du modèle

T - Le type des éléments.
T doit satisfaire aux exigences de CopyAssignable et CopyConstructible . (jusqu'à C++11)
Les exigences imposées aux éléments dépendent des opérations effectivement réalisées sur le conteneur. Généralement, il est requis que le type d'élément soit un type complet et satisfasse aux exigences de Erasable , mais de nombreuses fonctions membres imposent des exigences plus strictes. (depuis C++11)

Allocator - Un allocateur utilisé pour acquérir/libérer la mémoire et pour construire/détruire les éléments dans cette mémoire. Le type doit satisfaire aux exigences de Allocator . Le comportement est indéfini (jusqu'à C++20) Le programme est mal formé (depuis C++20) si Allocator::value_type n'est pas identique à T .

Invalidation des itérateurs

Opérations Invalidées
Toutes les opérations en lecture seule. Jamais.
swap , std::swap L'itérateur past-the-end peut être invalidé (défini par l'implémentation).
shrink_to_fit , clear , insert ,
emplace , push_front , push_back ,
emplace_front , emplace_back
Toujours.
erase Si effacement au début - seulement les éléments effacés.

Si effacement à la fin - seulement les éléments effacés et l'itérateur past-the-end.
Sinon - tous les itérateurs sont invalidés.

Il n'est pas spécifié quand l'itérateur past-the-end est invalidé.

(until C++11)

L'itérateur past-the-end est également invalidé sauf si les éléments
effacés sont au début du conteneur et que le dernier
élément n'est pas effacé.

(since C++11)
resize Si la nouvelle taille est plus petite que l'ancienne - seulement les éléments effacés et
l'itérateur past-the-end.

Si la nouvelle taille est plus grande que l'ancienne - tous les itérateurs sont invalidés.
Sinon - aucun itérateur n'est invalidé.

pop_front , pop_back Vers l'élément effacé.

L'itérateur past-the-end peut être invalidé (défini par l'implémentation).

(until C++11)

L'itérateur past-the-end est également invalidé.

(since C++11)

Notes d'invalidation

  • Lors de l'insertion à l'une ou l'autre extrémité du deque, les références ne sont pas invalidées par insert et emplace .
  • push_front , push_back , emplace_front et emplace_back n'invalident aucune référence aux éléments du deque.
  • Lors de la suppression à l'une ou l'autre extrémité du deque, les références aux éléments non supprimés ne sont pas invalidées par erase , pop_front et pop_back .
  • Un appel à resize avec une taille plus petite n'invalide aucune référence aux éléments non supprimés.
  • Un appel à resize avec une taille plus grande n'invalide aucune référence aux éléments du deque.

Types membres

Type de membre Définition
value_type T
allocator_type Allocator
size_type Type entier non signé (généralement std::size_t )
difference_type Type entier signé (généralement std::ptrdiff_t )
reference value_type &
const_reference const value_type &
pointer

Allocator::pointer

(jusqu'en C++11)

std:: allocator_traits < Allocator > :: pointer

(depuis C++11)
const_pointer

Allocator::const_pointer

(jusqu'en C++11)

std:: allocator_traits < Allocator > :: const_pointer

(depuis C++11)
iterator LegacyRandomAccessIterator et ConstexprIterator (depuis C++26) vers value_type
const_iterator LegacyRandomAccessIterator et ConstexprIterator (depuis C++26) vers const value_type
reverse_iterator std:: reverse_iterator < iterator >
const_reverse_iterator std:: reverse_iterator < const_iterator >

Fonctions membres

construit le deque
(fonction membre publique)
détruit la deque
(fonction membre publique)
assigne des valeurs au conteneur
(fonction membre publique)
assigne des valeurs au conteneur
(fonction membre publique)
assigne une plage de valeurs au conteneur
(fonction membre publique)
retourne l'allocateur associé
(fonction membre publique)
Accès aux éléments
accéder à l'élément spécifié avec vérification des limites
(fonction membre publique)
accéder à l'élément spécifié
(fonction membre publique)
accéder au premier élément
(fonction membre publique)
accéder au dernier élément
(fonction membre publique)
Itérateurs
retourne un itérateur vers le début
(fonction membre publique)
(C++11)
retourne un itérateur vers la fin
(fonction membre publique)
retourne un itérateur inverse vers le début
(fonction membre publique)
(C++11)
retourne un itérateur inverse vers la fin
(fonction membre publique)
Capacité
vérifie si le conteneur est vide
(fonction membre publique)
retourne le nombre d'éléments
(fonction membre publique)
retourne le nombre maximum possible d'éléments
(fonction membre publique)
réduit l'utilisation de la mémoire en libérant la mémoire inutilisée
(fonction membre publique)
Modificateurs
efface le contenu
(fonction membre publique)
insère des éléments
(fonction membre publique)
insère une plage d'éléments
(fonction membre publique)
(C++11)
construit un élément en place
(fonction membre publique)
efface les éléments
(fonction membre publique)
ajoute un élément à la fin
(fonction membre publique)
construit un élément sur place à la fin
(fonction membre publique)
ajoute une série d'éléments à la fin
(fonction membre publique)
supprime le dernier élément
(fonction membre publique)
insère un élément au début
(fonction membre publique)
construit un élément sur place au début
(fonction membre publique)
ajoute une plage d'éléments au début
(fonction membre publique)
supprime le premier élément
(fonction membre publique)
modifie le nombre d'éléments stockés
(fonction membre publique)
échange le contenu
(fonction membre publique)

Fonctions non membres

(supprimé en C++20) (supprimé en C++20) (supprimé en C++20) (supprimé en C++20) (supprimé en C++20) (C++20)
compare lexicographiquement les valeurs de deux deque s
(modèle de fonction)
spécialise l'algorithme std::swap
(modèle de fonction)
efface tous les éléments satisfaisant des critères spécifiques
(modèle de fonction)

Guides de déduction

(depuis C++17)

Notes

Macro de test de fonctionnalité Valeur Std Fonctionnalité
__cpp_lib_containers_ranges 202202L (C++23) Construction et insertion de plages pour les conteneurs
__cpp_lib_constexpr_deque 202502L (C++26) constexpr std::deque

Exemple

#include <deque>
#include <iostream>
int main()
{
    // Créer un deque contenant des entiers
    std::deque<int> d = {7, 5, 16, 8};
    // Ajouter un entier au début et à la fin du deque
    d.push_front(13);
    d.push_back(25);
    // Itérer et afficher les valeurs du deque
    for (int n : d)
        std::cout << n << ' ';
    std::cout << '\n';
}

Sortie :

13 7 5 16 8 25

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR Appliqué à Comportement publié Comportement corrigé
LWG 230 C++98 T n'était pas requis d'être CopyConstructible
(un élément de type T pourrait ne pas pouvoir être construit)
T est également requis
d'être CopyConstructible

Voir aussi

adapte un conteneur pour fournir une file d'attente (structure de données FIFO)
(modèle de classe)