Files d'attente de tâches en C++ : Guide complet pour débutants

Introduction aux files d'attente de tâches en C++

La file d'attente de tâches (queue) est l'une des structures de données fondamentales en programmation, qui fonctionne selon le principe FIFO (First In, First Out) : le premier élément ajouté sera le premier extrait. Imaginez une file d'attente classique dans un magasin — le premier client est servi en premier. En C++, le travail avec les files d'attente est implémenté via le conteneur std::queue, qui fait partie de la bibliothèque de modèles standard (STL).

Dans cet article, nous allons détailler comment créer, remplir et traiter des files d'attente de tâches en C++. Vous découvrirez les méthodes disponibles, comment éviter les erreurs courantes et comment les files d'attente sont utilisées dans des projets réels, des systèmes multithreads au traitement de requêtes.

Opérations de base avec une file d'attente de tâches

Création et initialisation d'une file d'attente

Pour utiliser une file d'attente en C++, vous devez inclure le fichier d'en-tête <queue>. Une file d'attente de base se déclare ainsi :

#include <iostream>#include <queue>

int main() {    std::queue<int> taskQueue; // File d'attente d'entiers    return 0;}

Vous pouvez créer une file d'attente pour tout type de données — chaînes de caractères, structures personnalisées, pointeurs. Par exemple, une file d'attente de tâches pour le traitement de commandes :

#include <queue>#include <string>

struct Order {    int id;    std::string description;};

int main() {    std::queue<Order> orderQueue;    return 0;}

Ajout et suppression d'éléments

Les méthodes principales pour travailler avec une file d'attente :

• push() — ajoute un élément à la fin de la file d'attente
• pop() — supprime le premier élément de la file d'attente
• front() — retourne une référence au premier élément (sans le supprimer)
• back() — retourne une référence au dernier élément
• empty() — vérifie si la file d'attente est vide
• size() — retourne le nombre d'éléments

Examinons un exemple avec un traitement pas à pas des tâches :

#include <iostream>#include <queue>

int main() {    std::queue<std::string> tasks;

    // Ajout des tâches    tasks.push("Tâche 1 : Vérifier les emails");    tasks.push("Tâche 2 : Rédiger le rapport");    tasks.push("Tâche 3 : Tenir une réunion");

    std::cout << "Première tâche : " << tasks.front() << std::endl;    std::cout << "Dernière tâche : " << tasks.back() << std::endl;    std::cout << "Nombre total de tâches : " << tasks.size() << std::endl;

    // Traitement des tâches une par une    while (!tasks.empty()) {        std::cout << "Exécution : " << tasks.front() << std::endl;        tasks.pop(); // Suppression de la tâche effectuée    }

    std::cout << "Toutes les tâches sont terminées !" << std::endl;    return 0;}

Résultat de l'exécution :

Première tâche : Tâche 1 : Vérifier les emailsDernière tâche : Tâche 3 : Tenir une réunionNombre total de tâches : 3Exécution : Tâche 1 : Vérifier les emailsExécution : Tâche 2 : Rédiger le rapportExécution : Tâche 3 : Tenir une réunionToutes les tâches sont terminées !

Files d'attente prioritaires : quand l'ordre est important

Parfois, les tâches ont des priorités différentes. Par exemple, une erreur critique doit être traitée avant une mise à jour planifiée. Dans ce cas, on utilise std::priority_queue, qui trie automatiquement les éléments par priorité.

#include <iostream>#include <queue>#include <vector>

int main() {    // Par défaut — priorité maximale pour l'élément le plus grand    std::priority_queue<int> highPriorityTasks;

    highPriorityTasks.push(5); // Tâche normale    highPriorityTasks.push(10); // Tâche urgente    highPriorityTasks.push(1); // Faible priorité

    while (!highPri