在C++中实现堆栈，无需使用<stack>

Implementation of stack in C++ without using <stack>

本文关键字：gt lt stack C++ 实现堆栈更新时间：2023-10-16

我想实现堆栈，我在互联网上找到了一个工作模型，不幸的是，它是基于我知道我想立即实现的堆栈大小的想法。我想做的是能够根据需要将段添加到堆栈中，因为所需插槽的最大数量可能达到10万个，根据我的理解，将大小设置为石头大小（大多数时候不需要所有这些）是对内存的巨大浪费和程序执行速度的损失。我也不想在我的实现中使用任何复杂的预写函数（STL或不同库（如vector等）提供的函数），因为我想通过尝试自己/在简短的帮助下制作它们来更多地理解所有这些函数。

        struct variabl {
            char *given_name;
            double value;
        };
        variabl* variables[50000];
        int c = 0;
        int end_of_stack = 0;
        class Stack
        {
        private:
            int top, length;
            char *z;
            int index_struc = 0;

        public:
            Stack(int = 0);
            ~Stack();
            char pop();
            void push();
        };
        Stack::Stack(int size) /* 
This is where the problem begins, I want to be able to allocate the size 
      dynamically.
    */
     {
            top = -1;
            length = size;
            z = new char[length];
        }
        void Stack::push()
        {
            ++top;
            z[top] = variables[index_struc]->value;
            index_struc++;
        }
        char Stack::pop()
        {
            end_of_stack = 0;
            if (z == 0 || top == -1)
            {
                end_of_stack = 1;
                return NULL;
            }
            char top_stack = z[top];
            top--;
            length--;
            return top_stack;
        }
        Stack::~Stack()
        {
            delete[] z;
        }

我有点想法，试着做

Stack stackk
//whenever I want to put another thing into stack
stackk.push = new char;

但后来我不完全理解它将如何实现我的目的，我认为它不能完全使用pop方法等访问，因为它将是一组单独的数组/变量，对吧？我希望实现保持相当简单，这样我就能理解它。

更改push函数以获取参数，而不需要引用variables。

要处理推送，请从数组的初始长度z开始（然后将z更改为更好的变量名）。当您推送新值时，请检查新值是否意味着数组的大小太小（通过比较length和top）。如果它将超过当前大小，则分配一个更大的数组，并将值从z复制到新数组，释放z，并使z指向新数组。

这里有一个简单的实现，不需要重新分配数组。它使用辅助类Node，它保存一个值，以及指向另一个Node的指针（设置为NULL表示堆栈的末尾）。

main（）通过读取形式的命令来测试堆栈

pc：将c推到堆栈

g：打印堆叠顶部并弹出

#include <cstdlib>
#include <iostream>
using namespace std;
class Node {
    private:
    char c;
    Node *next;
    public:
    Node(char cc, Node *nnext){
        c = cc;
        next = nnext;
    }
    char getChar(){
        return c;
    }
    Node *getNext(){
        return next;
    }
    ~Node(){}
};
class Stack {
    private:
    Node *start;
    public:
    Stack(){
        start = NULL;
    }
    void push(char c){
        start = new Node(c, start);
    }
    char pop(){
        if(start == NULL){
            //Handle error
            cerr << "pop on empty stack" << endl;
            exit(1);
        }
        else {
            char r = (*start).getChar();
            Node* newstart = (*start).getNext();
            delete start;
            start = newstart;
            return r;
        }
    }
    bool empty(){
        return start == NULL;
    }
};
int main(){
    char c, k;
    Stack st;
    while(cin>>c){
        switch(c){
            case 'p':
                cin >> k;
                st.push(k);
                break;
            case 'g':
                cout << st.pop()<<endl;
                break;
        }
    }
    return 0;
}