std:: deque
|
Défini dans l'en-tête
<deque>
|
||
|
template
<
class
T,
|
(1) | |
|
namespace
pmr
{
template
<
class
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
|
(depuis C++26) |
Table des matières |
Paramètres du modèle
| T | - |
Le type des éléments.
|
||||
| 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
|
Cette section est incomplète
Raison : Il subsiste encore quelques inexactitudes dans cette section, veuillez consulter les pages des fonctions membres individuelles pour plus de détails |
| 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.
|
||||
| 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.
|
||||
| pop_front , pop_back |
Vers l'élément effacé.
|
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
|
|
||||
const_pointer
|
|
||||
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) |
|
|
(C++23)
|
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 |
|
|
(C++11)
|
retourne un itérateur vers le début
(fonction membre publique) |
|
(C++11)
|
retourne un itérateur vers la fin
(fonction membre publique) |
|
(C++11)
|
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) |
|
|
(
DR*
)
|
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) |
|
|
(C++23)
|
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) |
|
|
(C++11)
|
construit un élément sur place à la fin
(fonction membre publique) |
|
(C++23)
|
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) |
|
|
(C++11)
|
construit un élément sur place au début
(fonction membre publique) |
|
(C++23)
|
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) |