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];
}

这是结果讲解一下吧谢谢

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

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

这有个类似的问题, 你可以参考下: https://ask.csdn.net/questions/7706005
这篇博客你也可以参考下：【带你了解C++标准库为何在八大链表结构中选择了它】双向循环带头链表的实质性操作
除此之外, 这篇博客: 【C++】构造函数无参构造函数有参构造函数拷贝构造函数内联函数中的 以成员函数的形式重载 部分也许能够解决你的问题, 你可以仔细阅读以下内容或者直接跳转源博客中阅读:
```
Complex & operator+=(const Complex &c);
Complex & operator-=(const Complex &c);
Complex & operator*=(const Complex &c);
Complex & operator/=(const Complex &c);
```
您还可以看一下夏曹俊老师的C++ 设计模式原理与实战大全-架构师需备课程课程中的将模型和视频与用户代码解耦合有门面模式的控制器来做小节, 巩固相关知识点

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

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

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