如何打印std:：stack的内容并返回其大小？ 在C++中，我如何打印栈的内容并返回其大小？< /p> std::stack<int> values; values.push(1); values.push(2); values.push(3); // How do I print the stack? std:：堆栈值； 值。推送（1）； 推送（2）； 推（3）； //如何打印堆栈？

就尺寸而言，它易于使用：

cout << mystack.size();

---

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

#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;
}

请在此处查看：打印
std:：stack
元素而不弹出它们的唯一方法是编写扩展
std:：stack
（）的适配器。否则，您应该用
std:：deque
替换堆栈
std:：stack
和
std:：queue
都是通用容器周围的包装。该容器可以作为受保护的
成员
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 );
}

#包括//std:：wcout、std:：endl
#include//std:：stack
#包括//ptrdiff\t
使用名称空间std；
typedef ptrdiff\t大小；
typedef大小索引；
模板
尺寸元件（堆栈常数和c）
{
返回c.size（）；
}
无效显示（堆栈常量和编号）
{
结构黑客
：公共堆栈
{
静态int项（索引常量i、堆栈常量和编号）
{
返回（数字。*&Hack:：c）[i]；
}
};
wcoutHm，一个将近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;
}


#包括
#包括
#包括
#包括
#包括
#包括
使用Number=int；
使用underyingcontainer=std:：vector；
使用Stack=std：：Stack；
std:：istringstream测试数据（“58143”）；
int main（）
{
//将测试数据放在堆栈上
堆栈{underyingcontainer{std:：istream_iterator（testData），std:：istream_iterator（）}；
//打印测试数据
if（不是stack.empty（））
std:：copy（&stack.top（）+1-stack.size（），&stack.top（）+1，std:：ostream\u迭代器（std:：cout，“\n”）；
返回0；
}

这是完全有效和可靠的代码

我们想要输出数据，所以我们将其复制到一个ostream_迭代器。ostream_迭代器引用一个流（是的，你也可以放一个OpenofStream）和一个deliminator。也许你想使用一个“”

副本的源是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;
}

#包括
#包括
#包括
#包括
#包括
#包括
使用Number=int；
使用underyingcontainer=std:：vector；
使用Stack=std：：Stack；
使用StackIterator=const Number*；
std:：istringstream测试数据（“58143”）；
int main（）
{
//将测试数据放在堆栈上
堆栈{underyingcontainer{std:：istream_iterator（testData），std:：istream_iterator（）}；
//打印测试数据
//获取迭代器
StackIterator end=&stack.top（）+1；
StackIterator begin=end-stack.size（）；
if（不是stack.empty（））
std:：copy（开始、结束、std:：ostream_迭代器（std:：cout，“\n”）；
返回0；
}

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

std:：stack故意将其元素隐藏在引擎盖下。因此，如果您写入访问数据，我会将其视为设计错误。通过常量指针/迭代器进行读取访问对我来说是可以的。但也许您最好使用std:：vector…
一种不使用“特殊技术”的简单方法是

递归

由于没有不能使用
std:：stack
的
pop（）
成员函数等的边界，我们可以使用以下递归算法

算法：

基本情况：如果堆栈为空=>返回


弹出顶部元素并将其存储在变量中


打印存储的值


递归调用堆栈的其余元素

std::cout << values.size () << std::endl;


将元素再次推到堆栈上

std::cout << values.size () << std::endl;

在这里输入代码


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

std::cout << values.size () << std::endl;

以下是上述算法的代码：

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);
}

这将以自上而下的方式打印元素

如果希望从下到上打印元素，只需切换递归调用和
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);
}

可以使用
std:：stack
的
size（）
成员函数来获取堆栈的大小

std::cout << values.size () << std::endl;

std:：cout你想要什么格式？没有办法让每个人都满意的格式。你说的
stack
是什么意思？你是说
std:：stack
还是说
call stack
或其他堆栈。请在细节上更具体一点。比如说，如果我有一堆整数a，我就把整数按a我怎样才能打印出1，2，3？它不会清空他的堆栈吗？有没有一个不弹出的解决方案？不会的，因为我先复制它（进入
dump
）。没有弹出的解决方案就是没有堆栈的解决方案。如果你需要随机访问（通用）容器，不要使用堆栈容器适配器。不是真的，这只是