Question

如果我不想创建一个新容器以便这样做？

Answer 1

我已经编写了一个片段来进行调试。例如：

std::stack<int> s; // works with std::queue also!
s.push(1);
s.push(2);

std::cout << s; // [ 1, 2 ]

请原谅我这个hackish代码！但这是我几个月前写的：

#include <stack>
#include <queue>
#include <ostream>

template <class Container, class Stream>
Stream& printOneValueContainer
    (Stream& outputstream, const Container& container)
{
    typename Container::const_iterator beg = container.begin();

    outputstream << "[";

    while(beg != container.end())
    {
        outputstream << " " << *beg++;
    }

    outputstream << " ]";

    return outputstream;
}

template < class Type, class Container >
const Container& container
    (const std::stack<Type, Container>& stack)
{
    struct HackedStack : private std::stack<Type, Container>
    {
        static const Container& container
            (const std::stack<Type, Container>& stack)
        {
            return stack.*&HackedStack::c;
        }
    };

    return HackedStack::container(stack);
}

template < class Type, class Container >
const Container& container
    (const std::queue<Type, Container>& queue)
{
    struct HackedQueue : private std::queue<Type, Container>
    {
        static const Container& container
            (const std::queue<Type, Container>& queue)
        {
            return queue.*&HackedQueue::c;
        }
    };

    return HackedQueue::container(queue);
}

template
    < class Type
    , template <class Type, class Container = std::deque<Type> > class Adapter
    , class Stream
    >
Stream& operator<<
    (Stream& outputstream, const Adapter<Type>& adapter)
{
    return printOneValueContainer(outputstream, container(adapter));
}

您可以像其他任何受支持的类型一样流式传输std::stack和std::queue！

Answer 2

您无法遍历堆栈或队列。事实上，SGI的文档说明了这一点（它是关于堆栈的，但它与排队的原因相同）：

此限制是堆栈完全存在的唯一原因。请注意，任何前插入序列或后插入序列都可以用作堆栈;例如，在vector的情况下，堆栈操作是成员函数back，push_back和pop_back。使用容器适配器堆栈的唯一原因是要明确表示您只执行堆栈操作，而不执行其他操作。

所以，如果你真的想要这样做，你将不得不清空堆栈（或队列）：

std::stack<Whatever> s;
// ...
while(!s.empty())
{
    Whatever w = s.top();
    std::cout << w;
    s.pop();
}

Answer 3

如果您需要这样做，那么堆栈或队列不是容器的正确选择。
如果您仍然坚持这样做，最好的方法是复制并弹出元素并打印出来。我不会建议另一种方式，因为没有意义。

Answer 4

ostream & operator<<(ostream & os, stack<double> my_stack) //function header
{
    while(!my_stack.empty()) //body
    {
        os << my_stack.top() << " ";
        my_stack.pop();
    }
    return os; // end of function
}


/*
using this simple overloaded operator function, you're able to print out all the components of a stack by doing a simple cout << your_stack_name;*/

Answer 5

使用递归可以轻松完成，您只需要知道何时重新添加下一个元素

For Stack

void print(stack<char> &s)
{
    if(s.empty())
    {
        cout << endl;
        return;
    }
    char x= s.top();
    s.pop();
    print(s);
    s.push(x);
    cout << x << " ";
 }

这个 For Queue

void print(queue<char> &s,int num)
{
    if(!num)
    {
        cout << endl;
        return;
    }
    char x= s.front();
    s.pop();
    cout << x << " ";
    s.push(x);
    print(s,--num);
}

祝你好运

Answer 6

发布b / c我发现这对调试很有用。从原版弹出到临时版，然后从temp回弹到原版：

template <typename T>
void dump_stack(std::stack<T>& stack) {
  std::stack<T> temp;
  while (!stack.empty()) {
    T top = stack.top(); stack.pop();
    std::cout << top << " ";
    temp.push(top);
  }
  while (!temp.empty()) {
    T top = temp.top(); temp.pop();
    stack.push(top);
  }
}

Answer 7

我找到了解决方案，它应该适用于std :: stack的所有实现（IMO），但不幸的是堆栈必须使用std :: vector而不是queue。

template<typename T>
void printStack(const std::stack<T, std::vector<T>>& s)
{
    typedef typename std::stack<T>::const_reference EntryTypeRef;
    typedef std::remove_reference_t<EntryTypeRef> EntryType;

    for(size_t i=0; i < s.size(); ++i)
    {
        EntryType* e = &s.top();
        cout << *(e-i) << endl;
    }
}

std :: vector是动态数组，所以我们可以使用指针arytmetics。

这个问题的明确答案假设，堆栈有一个名为'c'的字段，我有另一个解决方案可以使用std :: stack实现，它有容器作为第一个字段，但它的名字无关紧要：

template<typename T>
void printStack(const std::stack<T>& s)
{
    typedef typename std::stack<T>::container_type Container;

    const auto containerPtr = reinterpret_cast<const Container*>(&s);

    for(auto e : *containerPtr)
        cout << e << endl;
}

Answer 8

尝试一下：

template<typename T, typename C>
struct myStack : std::stack<T, C> {
    typedef std::stack<T, C> Stack;
    using Stack::stack;
    using Stack::c;                   
};

int main() 
{
    myStack<int, std::deque<int>> s;
    s.push(1);
    s.push(2);

    std::deque<int>::iterator it = s.c.begin();
    while (it != s.c.end())
        std::cout << ' ' << *it++;
}

在这里，我们将std :: stack的基础容器公开为成员c。

如何方便地打印出std :: stack或std :: queue中的所有元素

8 个答案: