Question

我使用下一个类实现了一个堆栈：

template <typename T, int lungime> class Depou
{
    private:

        T *depouarray;
        int top;

    public:

        Depou ()
        {
            this -> top = -1;
            depouarray = (T *) calloc (lungime, sizeof (T));

        }

        ~Depou ()
        {
            free (depouarray);
        }

        void push (T x)
        {
            if (top >= lungime - 1)
            {
                return;
            }

            top ++;
            depouarray [top] = x;   
        }

        T pop ()
        {
            if (isEmpty ())
            {
                return -1;
            }
            T x;
            x = depouarray [top];
            top --;
            return x;   
        }

        T peek ()
        {
            if (isEmpty ())
            {
                return -1;
            }
            return depouarray[top];
        }

        int isEmpty ()
        {
            return (top < 0);
        }
}

我的问题是下一个问题：在我将一个元素添加到堆栈后，让我们说3，我验证了它，它显示了3。接下来，我添加了另一个元素，让我们说4，我验证了堆栈的内容，它显示了一个非常高的数字（肯定是垃圾）和4.我无法理解为什么它将第一个元素转换为垃圾，只留下最后一个元素添加应该是。

Answer 1

正如我的同事所指出的那样，你的代码中有很多错误，我认为我需要付出太多努力来纠正它。因此我给你一个堆栈实现。

堆栈是FILO结构。实现它的最佳方法是使用Node并将它们链接在一起。看看下面的代码，它是直截了当的。如果您有疑问，请告诉我。

template <class T>
class Stack {
public:
    Stack();
    ~Stack();
    void push(const T&);
    void pop(T& out);
    T pop();
    bool is_empty() const;
    void clear();
private:
    class Node {
    public:
        Node(const T& t, Node* c);
        T contain;
        Node* next;
    };
    Node* peak;

};

template <class T>
Stack<T>::Stack()
{
    peak = NULL;
}

template <class T>
Stack<T>::~Stack()
{
    clear();
}

template <class T>
bool Stack<T>::is_empty() const
{
    return peak == NULL;
}

template <class T>
void Stack<T>::clear()
{
    while(!is_empty())
        pop();
}

template <class T>
Stack<T>::Node::Node(const T& t, Node* c) : next(c)
{
    contain = t;
}

template <class T>
void Stack<T>::push(const T& t)
{
    peak = new Node(t, peak);
    assert(peak);
}

template <class T>
T Stack<T>::pop()
{
    assert(peak);
    Node c(*peak);
    delete peak;
    peak = c.next;
    return c.contain;
}

template <class T>
void Stack<T>::pop(T& t)
{
    assert(peak != NULL);
    t = peak->contain;
    Node* c = peak;
    peak = peak->next;
    delete c;
}

堆栈实现C ++

1 个答案: