La classe queue (File d'attente) en C++ (bibliothèque STL) <queue>

La classe queue, définie dans <queue>, est un adaptateur de conteneur conçu pour l'insertion à une extrémité et la suppression à l'autre. Elle suit le principe FIFO (First In, First Out) : le premier élément inséré est le premier à être retiré.

Principe FIFO Les éléments sont poussés (push) à l'arrière (back) de la file et retirés (pop) depuis l'avant (front).

Conteneur sous-jacent

La file délègue son stockage à un conteneur qui doit supporter les opérations empty, size, front, back, push_back et pop_front. Les conteneurs deque et list satisfont ces exigences. Par défaut, c'est deque qui est utilisé.

Déclaration C++

#include <queue>

queue<type_objets> nomFile;                       // Conteneur sous-jacent : deque (défaut)
queue<type_objets, list<type_objets>> nomFile;    // Conteneur sous-jacent : list

Opérations

Fonction	Description
`bool empty()`	Retourne `true` si la file est vide.
`size_type size()`	Renvoie le nombre d'éléments dans la file.
`reference front()`	Renvoie une référence à l'élément le plus ancien — celui qui sera retiré au prochain `pop()`.
`reference back()`	Renvoie une référence à l'élément le plus récent — le dernier inséré.
`void push(val)`	Insère `val` à l'arrière de la file.
`void pop()`	Supprime l'élément à l'avant de la file — réduit la taille de 1.

Comparaison stack vs queue Dans une stack, insertion et suppression se font du même côté (le sommet). Dans une queue, l'insertion se fait à l'arrière (back) et la suppression à l'avant (front).

pop() ne retourne rien Comme pour stack, pop() supprime l'élément sans le retourner. Il faut appeler front() avant pop() pour récupérer la valeur.

Exemple complet

#include <iostream>
#include <queue>
using namespace std;

int main() {
    queue<int> file;
    file.push(10);
    file.push(20);
    file.push(50);
    file.push(70);
    file.push(30);

    cout << "Front (le plus ancien) : " << file.front() << '\n';
    cout << "Back  (le plus récent) : " << file.back()  << '\n';
    cout << "Taille : "                 << file.size()  << '\n';

    file.pop();  // Supprimer 10 (le plus ancien)

    // Parcourir et vider la file (ordre FIFO)
    cout << "Éléments restants (ordre FIFO) : ";
    while (!file.empty()) {
        cout << file.front() << ' ';
        file.pop();
    }
    cout << '\n';

    cout << "Taille finale : " << file.size() << '\n';
    return 0;
}

Sortie

Front (le plus ancien) : 10
Back  (le plus récent) : 30
Taille : 5
Éléments restants (ordre FIFO) : 20 50 70 30
Taille finale : 0

Parcourir une file sans la vider Comme pour stack, il n'y a pas d'itérateur sur queue. Le seul moyen de parcourir tous les éléments est de lire front() puis appeler pop() en boucle. Pour conserver les éléments, il faut les stocker dans un autre conteneur avant le parcours.

La classe queue (File d'attente) en C++ (bibliothèque STL) <queue>