C++ 我制作了自己的自定义堆栈，想知道如何反向迭代堆栈

这是接口文件

#ifndef STACK_H
#define STACH_H
#include<iostream>
using namespace std;

class Stack
{
    struct StackFrame{
        char data;
        StackFrame* next;
    };
    StackFrame* head;
public:
    Stack();
    void push(char);
    char pop();
    void empty();
    bool check_empty();
    void print();
    //Note:This code prints the data in stack format !!!
    ~Stack();
};



#endif // !STACK_H

#ifndef堆栈
#定义STACH_H
#包括
使用名称空间std；
类堆栈
{
结构堆栈框架{
字符数据；
StackFrame*下一步；
};
堆叠框架*头部；
公众：
堆栈（）；
无效推送（char）；
char-pop（）；
void empty（）；
bool check_empty（）；
作废打印（）；
//注意：此代码以堆栈格式打印数据！！！
~Stack（）；
};
#endif/！堆叠

这是实现文件

#include "Stack.h"

Stack::Stack():head(nullptr){}

void Stack::push(char c)
{
    StackFrame* temp = new  StackFrame;
    temp->data = c;
    temp->next = nullptr;

    if (head == nullptr)
    {
        head = temp;
        return;
    }

    temp->next = head;
    head = temp;
}

char Stack::pop()
{
    if (head == nullptr)
    {
        cerr << "There is nothing in the stack to pop at the moment!!!" << endl;
        return '\0';
    }

    StackFrame* holder = head;
    char temp_chr = holder->data;

    head = head->next;
    free(holder);
    holder = nullptr;

    return temp_chr;
}

void Stack::empty()
{
    StackFrame* holder;
    while(head!=nullptr)
    {
        holder = head;
        head = head->next;
        free(holder);
    }
    holder = nullptr;
    head = nullptr;
}

bool Stack::check_empty()
{
    return head==nullptr;
}

void Stack::print() {
    if (head == nullptr)
    {
        cerr << "Nothing in stack at the moment :( " << endl;
        return;
    }

    StackFrame* holder = head;
    while (holder != nullptr)
    {
        cout << holder->data;
        holder = holder->next;
    }
    cout << endl;
}

Stack::~Stack()
{
    empty();
}

#include"Stack.h"
#include<string>

int main()
{
    int num;
    string push;
    Stack st;
    cout << "Enter your name = ";
    getline(cin, push);
    for (int i = 0; i < push.length(); i++)
    {
        st.push(push[i]);
    }
    st.print();

    cout << "How many times do you want to pop? = ";
    cin >> num;
    for (int i = 0; i < num; i++)
    {
        st.pop();
    }
    st.print();
    return EXIT_SUCCESS;
}

#包括“Stack.h”
Stack:：Stack（）：head（nullptr）{}
void Stack:：push（char c）
{
StackFrame*temp=新的StackFrame；
温度->数据=c；
temp->next=nullptr；
if（head==nullptr）
{
压头=温度；
返回；
}
温度->下一步=头部；
压头=温度；
}
char Stack:：pop（）
{
if（head==nullptr）
{
cerr next；
免费（持有人）；
holder=nullptr；
返回温度；
}
void Stack:：empty（）
{
堆叠框架*支架；
while（head！=nullptr）
{
支架=头部；
头部=头部->下一步；
免费（持有人）；
}
holder=nullptr；
水头=零PTR；
}
bool Stack:：check_empty（）
{
返回压头==nullptr；
}
void Stack:：print（）{
if（head==nullptr）
{
cerr我认为您应该添加第二个堆栈对象，而不是第二个列表。
首先，如上所述，堆栈是后进先出的数据结构，因此应该使用另一个数据结构

第二，您可以使用第二个堆栈并将数据复制到新的堆栈，这非常昂贵

第三种选择是从顶部开始，将一个指向上一个节点和指向上一个节点上一个节点的指针的轨迹和存储区指针对齐。类似如下：

struct reverseStack {
    StackFrame* node;
    reverseStack* previousPointer;

    reverseStack (StackFrame* n, ReverseStack* p) :
        node (n), previousPointer(p) { }
}

reverseStack top (nullptr, topFrame);
StackFrame currentFrame = top->next();
ReverseStack current; = top;
while (currentFrame != nullptr) {
    // alghoritm for linking previous nodes.
}

与使用简单for循环相比，您可以创建指向顶部的指针，然后转到下一个，并将该信息存储到此结构中。在代码中，您有如下内容：

struct reverseStack {
    StackFrame* node;
    reverseStack* previousPointer;

    reverseStack (StackFrame* n, ReverseStack* p) :
        node (n), previousPointer(p) { }
}

reverseStack top (nullptr, topFrame);
StackFrame currentFrame = top->next();
ReverseStack current; = top;
while (currentFrame != nullptr) {
    // alghoritm for linking previous nodes.
}

递归算法会工作得很好（使用递归调用堆栈作为“反向”堆栈）

void Stack:：print（StackFrame*pCurr）{
如果（pCurr！=nullptr）
{
打印（pCurr->Next）；
coutch；
}
}
void Stack:：print（）{
if（head==nullptr）
{
cerr这对你没有多大帮助，但堆栈的要点是你只能与最顶层的元素交互。如果你可以迭代它，它就不是堆栈。真正的建议是，如果你想在两个方向上迭代，就不要使用那种堆栈（除非你想挑战自己，并以可能产生反效果的方式编写程序）。尽管如此，如果您真的愿意，您可以在将结果存储在第二个堆栈中的同时正常地迭代该堆栈，然后迭代第二个堆栈，这将给出相反的顺序。好的，我将使用delete而不是free（）@PajLe正是我的想法，这是我最初的想法，但后来意识到我将不再制作堆栈，但仍然感谢tipHmm…我最初确实想过在阵列上制作它，但后来没有实现，但现在我会研究它，谢谢提示