Comment parcourir la pile en C++?

Est-il possible de traverser std::stack en C++?

De la traversée de l'aide en suivant la méthode n'est pas applicable. Parce que std::stack n'a pas de membre end.

std::stack<int> foo;

//..

for (__typeof(foo.begin()) it = foo.begin(); it != foo.end();  it++)
{
    //...
}
C'est pourquoi elle est une "pile". Last in first out, c'est (théoriquement).
double possible de std::stack exposer les itérateurs?
Vous avez choisi le mauvais type de données. N'utilisez pas une pile si vous voulez être en mesure d'effectuer une itération sur elle.

OriginalL'auteur Silap Aliyev | 2014-04-21

  1. 13

    Est-il possible de traverser std::stack en C++?

    Pas. Une pile est une structure de données que vous devez utiliser lorsque vous êtes intéressé à placer des éléments sur le dessus et d'obtenir les éléments de la partie supérieure. Si vous voulez un objet iterable pile, soit utiliser une autre structure de données pour une pile de rôle (std::vector?) ou écrivez-en un vous-même.

    OriginalL'auteur utnapistim

  2. 2

    Je ne pas pense qu'il est possible de parcourir à travers un pile. Le mieux est, je pense, à l'aide de vecteur à l'aide de std::vector à l'aide de push_back(), pop_back()

    La pile ne fournit pas de début ou de fin de fonction de membre de sorte que vous ne pouvez pas l'utiliser avec un basé sur la plage pour la boucle qui nécessite à la fois.

    Dans votre cas, il serait préférable de choisir une autre structure de données si vous voulez vraiment itérer dessus.

    OriginalL'auteur Rahul Tripathi

  3. 2

    Comme vous l'avez mentionné vous avez besoin d'impression à des fins de débogage, peut-être quelque chose comme ça pourrait fonctionner pour vous:

    //Example program
#include <iostream>
#include <string>
#include <stack>
#include <vector>
#include <algorithm>

template <typename T>
void StackDebug(std::stack<T> s)
{
    std::vector<T> debugVector = std::vector<T>();
    while (!s.empty( ) )
    {
        T t = s.top( );
        debugVector.push_back(t);
        s.pop( );
    }

    //stack, read from top down, is reversed relative to its creation (from bot to top)
    std::reverse(debugVector.begin(), debugVector.end());
    for(const auto& it : debugVector)
    {
        std::cout << it << " ";
    }
}

int main()
{

    std::stack< int > numbers;
    numbers.push( 9 );
    numbers.push( 11 );

    StackDebug(numbers);
}

    Sortie est, comme prévu, "9 11"

    Quelqu'un en bas-voté ce parce que les piles ne sont pas suposed à l'utilisation de ce genre. Mais vous avez dit que c'est pour des fins de débogage, et vous avez raison. Les développeurs doivent agir dans la production, mais pour les tests est parfois nécessaire de briser certains comportements par défaut.

    OriginalL'auteur A. Knorre

  4. 1

    Nous ne pouvons pas traverser la pile. Les piles sont un type de conteneur adaptateur spécialement conçu pour fonctionner dans un LIFO contexte (last-in first-out), où les éléments sont insérés et extraits uniquement à partir de l'une des extrémités du récipient. Les éléments sont poussés/sauté du "retour" du conteneur spécifique, qui est connu comme le sommet de la pile. Il n'est pas prévu pour pile à montrer ce comportement, pour cela, nous avons d'autres conteneurs

    OriginalL'auteur DNamto

  5. 0
    #include <stack>

using std::stack;    

stack< int > numbers;
numbers.push( 1 );
numbers.push( 2 );

while ( not numbers.empty( ) )
{
    int number = numbers.top( );
    numbers.pop( );
}

    http://en.cppreference.com/w/cpp/container/stack

    Que les changements/vide la pile. Ce que je voulais était juste traverser la pile et l'imprimer à des fins de débogage.

    OriginalL'auteur Corvusoft

  6. -1

    Vous pouvez faire une boucle for:

    for (stack<T> newStack = stack; !newStack.empty(); newStack.pop()){
   T item = newStack.top();
}
    Je vois une erreur de syntaxe ici! Aussi, l'OP a la recherche d'une solution qui n'est pas de la pop tout.

    OriginalL'auteur Shaun Wang