C++ 不知道如何反转堆栈？

我正试图编写一个程序，使用链表实现一个堆栈，接受来自用户的无限单词，直到输入单词“end”，将每个单词推到堆栈上，向用户打印您已经接受了单词，您将要反向列出句子，并将每个单词弹出给用户，以便它们以与输入相反的顺序出现。 我已经编写了代码，但我认为我的pop函数可能有问题，因为它没有按相反的顺序打印。只是我输入信息的顺序，这意味着它不会弹出，对吗？我不确定

所以我只需要你帮我想办法 -将每个单词弹出给用户，使其按与输入相反的顺序显示

谢谢！ 这是我的密码：

#include<iostream>
#include<conio.h>
#include<stdlib.h>
using namespace std;
class node
{
      public:
             class node *next;
             string data;
};

class stack : public node
{
            node *head;
            int tos;
      public:
             stack()
             {
                 tos=-1;
             }
             void push(string x)
             {
                 if (tos < 0 )
                 {
                     head =new node;
                     head->next=NULL;
                     head->data=x;
                     tos ++;
                 }
                 else
                 {
                     node *temp,*temp1;
                     temp=head;

                     tos++;
                     while(temp->next != NULL)
                          temp=temp->next;
                     temp1=new node;
                     temp->next=temp1;
                     temp1->next=NULL;
                     temp1->data=x;
                 }
             }
             void display()
             {
                  node *temp;
                  temp=head;
                  if (tos < 0)
                  {
                      cout <<" stack under flow";
                      return;
                  }
                  while(temp != NULL)
                  {
                      cout <<temp->data<< " ";
                      temp=temp->next;
                  }
              }
              void pop()
              {
                  node *temp;
                  temp=head;
                  if( tos < 0 )
                  {
                      cout <<"stack under flow";
                      return;
                  }
                  tos--;
                  while(temp->next->next!=NULL)
                  {
                      temp=temp->next;
                  }
                  temp->next=NULL;
              }    
};
main()
{
    stack s1;
    string input;

    while (input != "end"){
        cout <<"\n enter a element";
        cin >> input;
        s1.push(input);
    }
    s1.pop();


    s1.display();

    exit(0);    
    return (0);
}

#包括
#包括
#包括
使用名称空间std；
类节点
{
公众：
类节点*next；
字符串数据；
};
类堆栈：公共节点
{
节点*头；
int tos；
公众：
堆栈（）
{
tos=-1；
}
无效推送（字符串x）
{
如果（tos<0）
{
头=新节点；
head->next=NULL；
头部->数据=x；
tos++；
}
其他的
{
节点*temp，*temp1；
温度=水头；
tos++；
while（临时->下一步！=NULL）
温度=温度->下一步；
temp1=新节点；
temp->next=temp1；
temp1->next=NULL；
temp1->data=x；
}
}
无效显示（）
{
节点*温度；
温度=水头；
如果（tos<0）
{
cout
int显示（节点*头部）
{
若有（总目）
{
显示（头部->下一步）；
coutdata
int显示（节点*头部）
{
若有（总目）
{
显示（头部->下一步）；
coutdata如果这应该是一个堆栈，那么你的插入逻辑就没有意义了。堆栈是后进先出的。这意味着在推送过程中你需要处理的唯一指针就是头指针；永远不要。你的下一个ptr节点指向当前头，然后头被设置到新节点上。（只要颠倒任何东西）您只需要一个临时节点。找出向量中有多少个条目。然后循环。获取节点[0]并将其分配给临时节点。然后获取节点[last]并将其分配给节点[0]，然后设置节点[last]你的问题是标签C++，但是你的代码>代码包含< /代码>等。在C++中，我们有<代码> STD:：Stase如果你被允许使用它。它也值得注意。代码>堆栈没有继承从<代码>节点< /C> >，并且<代码> tos < /C>根本不需要。你知道如果你在POP/期间要下溢你的堆栈。top/display，因为
head
将为空（即，没有要弹出的内容）。如果这是堆栈，则插入逻辑没有意义。堆栈是后进先出。这意味着在推送时需要处理的唯一指针是head指针；ever。下一个ptr节点指向当前head，然后head被设置为新节点。（就反转而言）您只需要一个临时节点。找出向量中有多少个条目。然后循环。获取节点[0]并将其分配给临时节点。然后获取节点[last]并将其分配给节点[0]，然后设置节点[last]你的问题是标签C++，但是你的代码>代码包含< /代码>等。在C++中，我们有<代码> STD:：Stase如果你被允许使用它。它也值得注意。代码>堆栈没有继承从<代码>节点< /C> >，并且<代码> tos < /C>根本不需要。你知道如果你在POP/期间要下溢你的堆栈。顶部/显示，因为
头部
将为空（即无需弹出任何内容）。
int display(node * head)
{
      if(head)
      {
            display(head->next);
            cout<< head->data <<endl;
      }
}