Namespaces
Variants

std:: queue

From cppreference.net
C++
Containers library
std::queue
Défini dans l'en-tête <queue>
template <

class T,
class Container = std:: deque < T >

> class queue ;

La std::queue est un adaptateur de conteneur qui fournit les fonctionnalités d'une file - plus précisément, une structure de données FIFO (premier entré, premier sorti).

Le modèle de classe agit comme un wrapper pour le conteneur sous-jacent - seul un ensemble spécifique de fonctions est fourni. La queue pousse les éléments à l'arrière du conteneur sous-jacent et les retire de l'avant.

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

Cependant, les objets std::queue ne peuvent généralement pas être constexpr , car toute allocation de mémoire dynamique 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 stockés. Le programme est mal formé si T n'est pas du même type que Container::value_type .
Container - Le type du conteneur sous-jacent utilisé pour stocker les éléments. Le conteneur doit satisfaire aux exigences de SequenceContainer . De plus, il doit fournir les fonctions suivantes avec la sémantique habituelle :

Les conteneurs standards std::deque et std::list satisfont à ces exigences.

Types membres

Type de membre Définition
container_type Container
value_type Container::value_type
size_type Container :: size_type
reference Container::reference
const_reference Container::const_reference

Objets membres

Nom du membre Définition
Container c
le conteneur sous-jacent
(objet membre protégé)

Fonctions membres

construit la queue
(fonction membre publique)
détruit la queue
(fonction membre publique)
assigne des valeurs à l'adaptateur de conteneur
(fonction membre publique)
Accès aux éléments
accède au premier élément
(fonction membre publique)
accède au dernier élément
(fonction membre publique)
Capacité
vérifie si l'adaptateur de conteneur est vide
(fonction membre publique)
renvoie le nombre d'éléments
(fonction membre publique)
Modificateurs
insère un élément à la fin
(fonction membre publique)
(C++23)
insère une plage d'éléments à la fin
(fonction membre publique)
(C++11)
construit un élément en place à la fin
(fonction membre publique)
supprime le premier élément
(fonction membre publique)
(C++11)
échange le contenu
(fonction membre publique)

Fonctions non membres

(C++20)
compare lexicographiquement les valeurs de deux queue s
(modèle de fonction)
(C++11)
spécialise l'algorithme std::swap
(modèle de fonction)

Classes d'assistance

(C++11)
spécialise le trait de type std::uses_allocator
(spécialisation de modèle de classe)
(C++23)
support de formatage pour std::queue
(spécialisation de modèle de classe)

Guides de déduction

(depuis C++17)

Notes

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

Exemple

Exécuter ce code 
#include <cassert>
#include <iostream>
#include <queue>
int main()
{
    std::queue<int> q;
    q.push(0); // back ajoute 0
    q.push(1); // q = 0 1
    q.push(2); // q = 0 1 2
    q.push(3); // q = 0 1 2 3
    assert(q.front() == 0);
    assert(q.back() == 3);
    assert(q.size() == 4);
    q.pop(); // supprime l'élément avant, 0
    assert(q.size() == 3);
    // Affiche et supprime tous les éléments. Notez que std::queue ne
    // prend pas en charge begin()/end(), donc une boucle for à portée ne peut pas être utilisée.
    std::cout << "q: ";
    for (; !q.empty(); q.pop())
        std::cout << q.front() << ' ';
    std::cout << '\n';
    assert(q.size() == 0);
}

Sortie : 

q: 1 2 3

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 307 C++98 std::queue ne prenait pas en charge les conteneurs utilisant des types
de référence par proxy [1] à la place de ( const ) value_type& 		pris en charge
LWG 2566 C++98 Manquait l'exigence pour Container::value_type mal formé si T n'est pas du même type que Container::value_type
  1. ↑ Tels que les conteneurs similaires à std::vector<bool> avec un support additionnel de pop_front() . La résolution de ce DR
    a ajouté le support de std::vector<bool> pour std::stack et std::priority_queue . Les modifications concernant std::queue
    visent à maintenir la cohérence.

Voir aussi

adapte un conteneur pour fournir une file à priorité
(modèle de classe)
file double face
(modèle de classe)
liste doublement chaînée
(modèle de classe)