for循环中的C++后缀增量;堆叠;组成/授权

我搜索了类似的问题，但找不到适用于我的情况的问题。我有一个使用数组类作为数据成员的堆栈类。我在大小为5的堆栈（在本例中为数据成员"Array m_Array"）上使用"main（）"中的推送和弹出来测试它。我使用for循环来用后缀增量填充堆栈，但它没有将0推入第一个元素，而是将1推入。我的输出是：

1
2
3
4
3
2
1
0
-1
Stack is full(empty)

但我希望它是

0
1
2
3...

测试中：

int main()
{
    try {
        Stack<int> s(5);
        for (int i = 0; i < 4; i++) {
            s.Push(i);
            cout << s << endl;
        }
        cout << endl;
        for (int i = 0; i < 8; ++i) {
            s.Pop();
            cout << s << endl;
        }
    }
    catch (ArrayException &ex)    //catch object
    {
        cout << ex.GetMessage() << endl;
    }
    catch(...)    //default catch
    {
        cout << "An unhandled exception has occurred" << endl;
    }
    return 0;
}

在stack.cpp中：

#ifndef STACK_CPP
#define STACK_CPP
#include "stack.h"
namespace Jules
{
    namespace Containers
    {
        template<typename T>    //default constructor
        Stack<T>::Stack() : m_array(Array<T>()), m_current(0)
        {
        }
        template<typename T>    //destructor
        Stack<T>::~Stack()
        {
        }
        template<typename T>    //copy constructor
        Stack<T>::Stack(const Stack<T> &s) : m_array(s.m_array), m_current(s.m_current)
        {
        }
        template<typename T>    //constructor with input argument
        Stack<T>::Stack(const int i) : m_array(i), m_current(0)
        {
        }
        template<typename T>    //assignment operator
        Stack<T> Stack<T>::operator=(Stack<T> const &source)
        {
            if (this == &source)
                return *this;
            Stack<T>::operator = (source);
            return *this;
        }
        template<typename T>    //push function
        void Stack<T>::Push(const T& element)
        {
            m_array[m_current] = element;
            ++m_current;
        }
        template<typename T>    //pop function
        void Stack<T>::Pop()
        {
            --m_current;
            m_array[m_current];
        }
        template<typename T2>    //send to ostream
        ostream& operator << (ostream& os, const Stack<T2>& t)
        {
            os << t.m_current;
            return os;
        }
    }
}
#endif