Maîtriser std::stack en C++ : Guide complet avec exemples pratiques

Qu'est-ce que std::stack ?

std::stack est un adaptateur de conteneur qui implémente le principe LIFO (Last In, First Out - dernier entré, premier sorti). Il permet l'insertion et la suppression d'éléments uniquement par une extrémité – le sommet. Par défaut, il utilise std::deque comme conteneur sous-jacent, mais tout conteneur de séquence (ex. std::vector ou std::list) peut être fourni.

Les adaptateurs de conteneurs n'exposent pas d'itérateurs, vous ne pouvez donc pas parcourir une pile directement. À la place, vous interagissez avec elle via ses fonctions membres.

Objectifs d'apprentissage

• Définir std::stack et comprendre son comportement LIFO
• Apprendre la syntaxe pour déclarer une pile
• Explorer les types membres et opérations clés
• Travailler avec push, pop, top, empty, size, emplace et swap
• Implémenter une pile dans la bibliothèque de modèles standard (STL)

Syntaxe

Incluez l'en-tête <stack> et déclarez une pile avec le template suivant :

template<class T, class Container = std::deque<T>> class stack;

• T – Type d'élément ; tout type C++ valide, y compris classes définies par l'utilisateur.
• Container – Conteneur sous-jacent ; par défaut std::deque.

Types membres

• value_type – Le type d'élément T.
• container_type – Le type du conteneur sous-jacent.
• size_type – Type intégral non signé pour la taille du conteneur.

Opérations principales

• push() – Ajoute un élément au sommet.
• pop() – Supprime l'élément du sommet.
• top() – Accède à l'élément du sommet sans le supprimer.
• empty() – Vérifie si la pile est vide.
• size() – Retourne le nombre d'éléments.
• emplace() – Construit et insère un élément directement au sommet.
• swap() – Échange le contenu avec une autre pile.

Vue d'ensemble de l'implémentation

Voici une représentation visuelle des opérations de pile (le sommet de la pile indiqué par le pointeur).

push() et pop()

La méthode push() ajoute un nouvel élément, augmentant la taille de un :

stack.push(valeur);

Inversement, pop() supprime l'élément du sommet et réduit la taille :

stack.pop();

Exemple 1 : Manipulation de base de pile

#include <iostream>
#include <stack>
using namespace std;
int main() {
    stack<int> st;
    st.push(10);
    st.push(20);
    st.push(30);
    st.push(40);
    st.pop(); // supprime 40
    st.pop(); // supprime 30
    while (!st.empty()) {
        cout << ' ' << st.top();
        st.pop();
    }
    return 0;
}

Sortie : 20 10

empty(), size(), top()

Ces fonctions utilitaires fournissent des informations rapides sur l'état de la pile.

Exemple 2 : Inspection de l'état de la pile

#include <iostream>
#include <stack>
using namespace std;
void display(stack<int> s) {
    while (!s.empty()) {
        cout << '\t' << s.top();
        s.pop();
    }
    cout << '\n';
}
int main() {
    stack<int> st;
    st.push(32);
    st.push(21);
    st.push(39);
    st.push(89);
    st.push(25);
    cout << "The stack st is: ";
    display(st);
    cout << "\n st.size() : " << st.size();
    cout << "\n st.top() : " << st.top();
    st.pop();
    cout << "\n st after pop: ";
    display(st);
    return 0;
}

Sortie : affiche le contenu de la pile, sa taille, l'élément du sommet et l'état après un pop.

emplace() et swap()

• emplace() construit un élément sur place, évitant une copie supplémentaire.
• swap() échange le contenu de deux piles efficacement.

Exemple 3 : Utilisation de emplace() et swap()

#include <iostream>
#include <stack>
using namespace std;
int main() {
    stack<int> st1, st2;
    st1.emplace(12);
    st1.emplace(19);
    st2.emplace(20);
    st2.emplace(23);
    st1.swap(st2);
    cout << "st1 = ";
    while (!st1.empty()) {
        cout << st1.top() << " ";
        st1.pop();
    }
    cout << endl << "st2 = ";
    while (!st2.empty()) {
        cout << st2.top() << " ";
        st2.pop();
    }
}

Sortie : démontre le contenu des piles avant et après l'échange.

Utilisation de std::stack dans la STL

Implémenter une pile en une seule ligne :

std::stack<T> st;

Exemple :

#include <iostream>
#include <stack>
using namespace std;
int main() {
    stack<int> st;
    st.push(12);
    st.push(19);
    st.push(20);
    cout << st.top(); // 20
    cout << st.size(); // 3
    return 0;
}

Résumé

• std::stack implémente LIFO et n'autorise l'accès qu'à l'élément du sommet.
• C'est un adaptateur de conteneur ; le conteneur sous-jacent par défaut est std::deque, mais peut être personnalisé.
• Fonctions principales : push, pop, top, empty, size, emplace, swap.
• La pile est un outil léger et efficace pour les scénarios nécessitant un stockage temporaire d'éléments.