如何打印出std :: stack的内容并返回其大小？

时间：2012-09-27 23:25:48

标签： c++ stack

在c ++中，如何打印出我的堆栈内容并返回其大小？

std::stack<int>  values;
values.push(1);
values.push(2);
values.push(3);

// How do I print the stack?

6 个答案:

答案 0 :(得分：16)

您可以逐个复制堆栈和弹出项目以转储它们：

#include <iostream>
#include <stack>
#include <string>

int main(int argc, const char *argv[])
{
    std::stack<int> stack;
    stack.push(1); 
    stack.push(3); 
    stack.push(7); 
    stack.push(19); 

    for (std::stack<int> dump = stack; !dump.empty(); dump.pop())
        std::cout << dump.top() << '\n';

    std::cout << "(" << stack.size() << " elements)\n";

    return 0;
}

输出

19
7
3
1
(4 elements)

在此处查看：http://liveworkspace.org/code/9489ee305e1f55ca18c0e5b6fa9b546f

答案 1 :(得分：4)

打印std::stack 的元素而不弹出的唯一方法是编写一个扩展std::stack（here's an example）的适配器。否则，您应该使用std::deque替换堆栈。

答案 2 :(得分：4)

std::stack和std::queue都是一般容器的包装器。该容器可以protected成员c访问。使用c，您可以获得对元素的高效访问权限;否则，您只需复制堆栈或队列并破坏性地访问副本的元素。

使用c：

的示例 
#include <iostream>     // std::wcout, std::endl
#include <stack>        // std::stack
#include <stddef.h>     // ptrdiff_t
using namespace std;

typedef ptrdiff_t   Size;
typedef Size        Index;

template< class Elem >
Size nElements( stack< Elem > const& c )
{
    return c.size();
}

void display( stack<int> const& numbers )
{
    struct Hack
        : public stack<int>
    {
        static int item( Index const i, stack<int> const& numbers )
        {
            return (numbers.*&Hack::c)[i];
        }
    };

    wcout << numbers.size() << " numbers." << endl;
    for( Index i = 0;  i < nElements( numbers );  ++i )
    {
        wcout << "  " << Hack::item( i, numbers ) << endl;
    }
}

int main()
{
    stack<int>  numbers;
    for( int i = 1;  i <= 5;  ++i ) { numbers.push( 100*i ); }

    display( numbers );
}

答案 3 :(得分：1)

无需使用“特殊技术”即可实现这一目标的简单方法是通过

<块引用>

递归

由于没有限制pop ()的{​​{1}}成员函数不能使用等，我们可以利用下面的递归算法。

算法：

  1. 基本情况：如果堆栈为空 => 返回。
  2. 弹出顶部元素并将其存储在变量中。
  3. 打印存储的值。
  4. 递归调用堆栈的其余元素。
  5. 再次将元素压入堆栈。

尽管进行了弹出操作，但堆栈不会丢失其元素，因为我们在打印堆栈的其余部分后以相同的顺序再次推送它们。

以上算法的代码如下：

std::stack<>

以上代码的输出：

void printStack (std::stack <int> &values) {
    
    if (values.empty ()) {
        return;
    }

    int topElement = values.top ();
    values.pop ();

    std::cout << topElement << std::endl;

    printStack (values);

    values.push (topElement);
}

这将打印从上到下时尚的元素。

如果您希望元素从下到上打印，只需切换递归调用和 3 2 1 语句。

std::cout

输出：

void printStack (std::stack <int> &values) {
    
    if (values.empty ()) {
        return;
    }

    int topElement = values.top ();
    values.pop ();

    printStack (values);

    std::cout << topElement << std::endl;

    values.push (topElement);
}

而1 2 3 的成员函数size ()可以用来获取栈的大小。

std::stack<>

答案 4 :(得分：0)

http://www.cplusplus.com/reference/stl/stack/ 这个尺寸很容易使用：

cout << mystack.size();

对于其余部分，我没有在文档中看到任何内容，但是当你按下它时应该打印堆栈的内容，或者有一个列表用它来保存元素的记录只是为了打印它，不要忘记在完成测试后删除它

答案 5 :(得分：0)

嗯，这是一个将近10年的问题。无论如何，这是一个额外的答案。

首先：堆栈的大小由std :: stack.size（）给出。

然后，在现代C ++中，越来越多地使用带有算法的STL。因此，以下解决方案利用了这一点。前提条件是堆栈使用连续内存。目前可以保证。

通过一根衬纸完成输出。

请参见以下示例：

#include <vector>
#include <stack>
#include <iostream>
#include <algorithm>
#include <iterator>
#include <sstream>

using Number = int;
using UnderlyingContainer = std::vector<Number>;
using Stack = std::stack< Number, UnderlyingContainer>;

std::istringstream testData("5 8 1 4 9 3");

int main()
{
    // Put the test data onto the stack
    Stack stack{ UnderlyingContainer {std::istream_iterator<Number>(testData),std::istream_iterator<Number>()} };

    // Print the test data
    if (not stack.empty())
        std::copy(&stack.top() + 1 - stack.size(), &stack.top() + 1, std::ostream_iterator<Number>(std::cout, "\n"));

    return 0;
}

这是完全有效和可靠的代码。这里有更多解释。

我们要输出数据，因此我们将其复制到ostream_iterator。 ostream_iterator引用了一个流（是的，您也可以放置一个开放的流）和分隔符。也许您想使用“”。

副本的源是2个迭代器。而且，是的，指针是迭代器。并且，我们将保证的连续内存用于std :: stack。因此，我们只需计算2个指针，然后将其移交给std :: copy。

如果要使用显式迭代器。开始了 。 。 

#include <vector>
#include <stack>
#include <iostream>
#include <algorithm>
#include <iterator>
#include <sstream>

using Number = int;
using UnderlyingContainer = std::vector<Number>;
using Stack = std::stack< Number, UnderlyingContainer>;

using StackIterator = const Number *;

std::istringstream testData("5 8 1 4 9 3");

int main()
{
    // Put the test data onto the stack
    Stack stack{ UnderlyingContainer {std::istream_iterator<Number>(testData),std::istream_iterator<Number>()} };

    // Print the test data
    // Get iterators
    StackIterator end = &stack.top() + 1;
    StackIterator begin = end - stack.size();

    if (not stack.empty())
        std::copy(begin, end, std::ostream_iterator<Number>(std::cout, "\n"));

    return 0;
}

因此，您可以为堆栈创建迭代器。但是，请注意：

std :: stack故意将其元素隐藏在引擎盖下。因此，如果您对数据进行写访问，我将其视为设计错误。对我来说，通过const指针/迭代器进行读取访问是可以的。但是也许您最好使用std :: vector。 。

相关问题
最新问题