c++用栈去写一个简单的计算机 能运行但没结果

c++用栈去写一个简单的计算机 能运行但没结果 麻烦看一看

#pragma once
#ifndef IMPROVEDSTACK_H
#define IMPROVEDSTACK_H
template<typename T>
class Stack
{
public:
    Stack();
    Stack(const Stack&);
    ~Stack();
    bool empty()const;
    T peek()const;
    void push(T value);
    T pop();
    int getSize()const;
private:
    T* elements;
    int size;
    int capacity;
    void ensureCapacity();
};
template<typename T>
Stack<T>::Stack() : size(0), capacity(16)
{
    elements = new T[capacity];
}
template<typename T>
Stack<T>::Stack(const Stack& stack)
{
    elements = new T[stack.capacity];
    size = stack.size();
    capacity = stack.capacity();
    for (int i = 0; i < size; i++)
    {
        elements[i] = stack.elements[i];
    }
}
template<typename T>
Stack<T>::~Stack()
{
    delete[] elements;
}
template<typename T>
bool Stack<T>::empty() const
{
    if (size == 0)
        return 1;
    else
        return  0;
}
template<typename T>
T Stack<T>::peek() const
{
    return elements[size - 1];
}
template<typename T>
void Stack<T>::push(T value)
{
    ensureCapacity();
    elements[size++] = value;
}
template<typename T>
void Stack<T>::ensureCapacity()
{
    if (size >= capacity)
    {
        T* old = elements;
        capacity = 2 * size;
        elements = new T[size * 2];
        for (int i = 0; i < size; i++)
            elements[i] = old[i];
        delete[] old;
    }
}
template<typename T>
T Stack<T>::pop()
{
    //size -= 1;
    return elements[--size];
}
template<typename T>
int Stack<T>::getSize() const
{
    return size;
}

#endif // !IMPROVEDSTACK_H


上边的是创建栈

#include<iostream>
#include<string>
#include<cctype>
#include<vector>
#include"ImprovedStack.h"
using namespace std;
vector<string> split(const string& expression);//将式子里的操作符 数字提取出来
int evaluateExpression(const string& expression);//计算并返回结果
void procscessAnOperator(Stack<int>& operandStack, Stack<char>& operatorStack);
//实现操作运算符来进行计算 operandStack是数字栈 operator是操作符栈
int main()
{
    string expression;
    getline(cin, expression);
    cout << expression << "=" << evaluateExpression(expression) << endl;
    return 0;
}
vector<string> split(const string& expression)
{
    vector<string> v;
    string numberoperand;
    for (unsigned i = 0; i < expression.size(); i++)
    {
        if (isdigit(expression[i]))
            numberoperand.append(1,expression[i]);
        else
        {
            if (numberoperand.size() > 0)//将数储存在v里
            {
                v.push_back(numberoperand);
                numberoperand.erase();//消除numberoperand里的数 防止重复储存
            }
            if(!isspace(expression[i]))//防止空白操作符
            {
                string s;
                s = expression[i];
                v.push_back(s);//添加操作符
            }
        }
    }
    if (numberoperand.size() > 0)//将最后的数字储存到v里
    {
        v.push_back(numberoperand);
    }
    return v;
}
int evaluateExpression(const string& expression)//计算并返回结果
{
    Stack<int> operandStack ;//储存数字 
    Stack<char> operatorStack;//存储操作符 + - * / ( )
    vector<string> v = split(expression);
    //要去判断数字并决定操作
    for (unsigned i = 0; i < v.size(); i++)
    {
        if (v[i][0] == '+' || v[i][0] == '- ')
        {
            while ((!operatorStack.empty()) && (operatorStack.peek() == ' + ' || operatorStack.peek() == ' - ' || operatorStack.peek() == ' * ' || operatorStack.peek() == ' / '))
            {
                procscessAnOperator(operandStack, operatorStack);
            }
                operatorStack.push(v[i][0]);
        }
        else if (v[i][0] == '*' || v[i][0] == '/ ')
        {
            while ((!operatorStack.empty()) && (operatorStack.peek() == '*' || operatorStack.peek() == '/'))
            {
                procscessAnOperator(operandStack, operatorStack);
            }
                operatorStack.push(v[i][0]);
        }
        else if (v[i][0] == '(')
        {
            operatorStack.push('(');
        }
        else if (v[i][0] == ')')
        {
            while (operatorStack.peek() != '(')
            {
                procscessAnOperator(operandStack, operatorStack);
            }
            operatorStack.pop();
        }
        else
        {
            operandStack.push(atoi(v[i].c_str()));
        }
        }
    while (!operandStack.empty())
    {
        procscessAnOperator(operandStack, operatorStack);
    }
    return operandStack.pop();
    }


void procscessAnOperator(Stack<int>& operandStack, Stack<char>& operatorStack)
{
    char op = operatorStack.pop();
    int op1 = operandStack.pop();
    int op2 = operandStack.pop();
    if (op == '+')
        operandStack.push(op2 + op1);
    else if(op=='-')
        operandStack.push(op2 - op1);
    else if (op == '*')
        operandStack.push(op2 * op1);
    if (op1 == 0)
    {
        op1 = 1;
    }
    else if (op == '/')
        operandStack.push(op2 / op1);
}


实现
但是调试器报错的是


template<typename T>
T Stack<T>::pop()
{
    //size -= 1;
    return elements[--size];
}

img

这是结果 讲解一下吧 谢谢

是不是elements那里没有判断size == 0

不知道你这个问题是否已经解决, 如果还没有解决的话:

如果你已经解决了该问题, 非常希望你能够分享一下解决方案, 写成博客, 将相关链接放在评论区, 以帮助更多的人 ^-^