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
不知道你这个问题是否已经解决, 如果还没有解决的话:Complex & operator+=(const Complex &c);
Complex & operator-=(const Complex &c);
Complex & operator*=(const Complex &c);
Complex & operator/=(const Complex &c);