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

我搜索了类似的问题，但没有找到一个适合我的情况。我有一个使用数组类作为数据成员的堆栈类。我在大小为5的堆栈上使用push和pop-in'main（）（在本例中是数据成员'Array m_Array'）测试它。我使用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;
}

intmain（）
{
试一试{
堆栈s（5）；
对于（int i=0；i<4；i++）{
s、 推（i）；
cout你的
操作符的代码什么是“操作符”它是ostream操作符，所以我可以堆叠对象。“它推1”。你怎么知道？你不是在打印推送的内容，而是在打印堆栈本身，用于打印堆栈的代码不可用。在
堆栈：：Pop（）
中，你的第一行是
m\u数组[m\u current]
。这实际上什么都不做（除了读取数组的边界外，但这是另一个故事）。你的意思是返回弹出的元素吗？我个人会将你的推送方法重写为：
m_数组[m_current++]=element；if（m_current>size）放大（）；
，而你的弹出方法是
if（m_current==0）抛出一些异常（）；返回m_数组[--m_当前值]
另外，也许你打算实现一个队列而不是堆栈？当你将1、2、3推到一个堆栈，然后弹出所有值时，你会得到3、2、1。对于一个队列，推1、2、3，然后弹出将得到1、2、3。据我所知，这是一个完美的关联，它在我的循环中不断弹出。我不明白问题出在哪里e、 我原来的帖子没有提到ostream操作符，我不明白你为什么要提到它？谢谢你说输出不正确。输出是用这行代码完成的
#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