基于堆栈的计算器

简单的基于堆栈的计算器

**（1）**接受用户的输入，输入形式有两种：数字、运算符。
**（2）**数字保存在堆栈中（LIFO类型内存），将数字推入堆栈。
**（3）**对堆栈顶端的两个数字出栈，应用运算符，若堆栈只有一个数字，将它重复，应用运算符。将计算结果，压入堆栈。
**（4）**使用逆波兰表示法（后缀法），例：“4+5”等价于“4 5 +”、“4+5-2”等价于“4 5 + 2 -
**（5）**实现4种运算”+ - * /“

设计（自顶向下）
（1）计算器对象为顶层对象。
（2）计算器使用堆栈保存了输入的数字，并对这些数字应用运算符。
（3）每次输入后，使用堆栈序列生成器，显示此时堆栈的内容。
（4）使用输入对象进行一些预处理（判别数字、运算符、非法输入），将用户输入的内容传递给计算器对象。
（5）输入对象从标准输入获得一个字符串，区别是数字还是运算符。如果是数字，将字符串转为数字，交给计算器对象压入堆栈。如果是运算符，交给计算器对象，实现此运算。
（6）计算器对象对堆栈每次操作后，使用堆栈序列生成器，输入堆栈当前内容。

具体实现
main.cpp

#include<iostream>
#include"calc.h"
int main()
{
	//计算器对象
	Calculator TheCalculator;
	//迭代状态
	bool status;
	do
	{
		std::cout << "> ";
		//输入对象
		Input input;
		status = TheCalculator.Execute(input);
		if (status)
		{
			for (StackSeq seq(TheCalculator.GetStack());//堆栈序列对象
				!seq.AtEnd();
				seq.Advance())
			{
				//输入堆栈内容
				std::cout << " " << seq.GetNum() << std::endl;
			}
		}
	} while (status);
}

计算器类
calc.h

#ifndef CALC_H
#define CALC_H
#include<iostream>
#include<cassert>
#include"input.h"
#include"stack.h"
class Calculator
{
public:
    //int const 等价于 const int
	bool Execute(Input const & input);
	//堆栈常量的引用（只读）
	IStack const & GetStack()
	{
		return _stack;
	}
private:
	//堆栈（嵌入对象）
	IStack _stack;
	//计算函数
	int Calculate(int num1, int num2, int token)const;
};
#endif

calc.cpp

#include"calc.h"

bool Calculator::Execute(Input const &input)
{
	//获得input对象的输入
	int token = input.Token();
	//初始时假定失败
	bool status = false;

	//错误
	if (token == tokError)
	{
		std::cout << "Unknown token\n";
	}
	//输入为数字
	else if (token == tokNumber)
	{
		if (_stack.IsFull())
		{
			std::cout << "Stack is full";
		}
		else
		{
			_stack.Push(input.Number());
			status = true;
		}
	}
	//输入为运算符号
	else
	{
		//契约：input不能产生任何其他字符
		assert(token == '+' || token == '-' || token == '*'
			|| token == '/');
		//堆栈空
		if(_stack.IsEmpty())
		{
			std::cout << "Stack is empty" << std::endl;
		}
		else
		{
			int num2 = _stack.Pop();
			int num1;
			//当堆栈只有一个数
			if (_stack.IsEmpty())
			{
				num1 = num2;
			}
			else
			{
				num1 = _stack.Pop();
			}
			//结果Push堆栈
			_stack.Push(Calculate(num1, num2, token));
			status = true;
		}
	}
	return status;
}
int Calculator::Calculate(int num1, int num2, int token) const
{
	int result;
	if (token == '+')
		result = num1 + num2;
	else if (token == '-')
		result = num1 - num2;
	else if (token == '*')
		result = num1 * num2;
	else if (token == '/')
	{
		if (num2 == 0)
		{
			std::cout << "Division by zero" << std::endl;
			result = 0;
		}
		else
			result = num1/num2;
	}
	return result;
}

堆栈与堆栈序列生成器
stack.h

#ifndef STACK_H
#define STACK_H
#include<iostream>
#include<cassert>
const int maxStack = 16;
//堆栈类
class IStack
{
	friend class StackSeq;
public:
	IStack() :_top(0){}
	void Push(int i);
	int Pop();
	//堆栈满
	bool IsFull();
	//堆栈空
	bool IsEmpty();
private:
	//实际数据类型 整型数组
	int _arr[maxStack];
	int _top;
};
//堆栈序列生成器类
class StackSeq
{
public:
	StackSeq(IStack const & stack) :_stack(stack), _iCur(0){}
	//是否到达堆栈尾端
	bool AtEnd();
	//堆栈当前索引内容
	int GetNum();
	//下一个索引
	void Advance();
private:
	//堆栈常量的引用
	IStack const & _stack;
	int _iCur;
};

#endif

stack.cpp

#include"stack.h"


void IStack::Push(int i)
{
	assert(_top < maxStack);
	_arr[_top] = i;
	_top++;
}
int IStack::Pop()
{
	assert(_top>0);
	--_top;
	return _arr[_top];
}
bool IStack::IsFull()
{
	if (_top < maxStack)
	{
		return false;
	}
	else
	{
		return true;
	}
}
bool IStack::IsEmpty()
{
	if (_top > 0)
	{
		return false;
	}
	else
	{
		return true;
	}
}
bool StackSeq::AtEnd()  
{
	return  _iCur==_stack._top;
}
void StackSeq::Advance()
{
	assert(!AtEnd());
	++_iCur;
}
int StackSeq::GetNum() 
{
	assert(!AtEnd());
	return _stack._arr[_iCur];
}

输入类
input.h

#ifndef INPUT_H
#define INPUT_H
#include<iostream>
#include<cctype>
#include<cassert>
#include<cstdlib>
const int maxBuf = 100;
const int tokNumber = 1;
const int tokError = 2;

class Input
{
public:
	Input();
	//将输入返回给计算器对象
	int Token()const{ return _token; }
	//字符串转数字
	int Number()const;
private:
	int _token;
	char _buf[maxBuf];
};
#endif

input.cpp

#include"input.h"

Input::Input()
{
	std::cin >> _buf;
	int c = _buf[0];
	if (std::isdigit(c))
		_token = tokNumber;
	else if (c == '+' || c == '*' || c == '/')
		_token = c;
	//允许输入负数
	else if (c == '-')
	{
		if (std::isdigit(_buf[1]))
			_token = tokNumber;
		else
			_token = c;
	}
	else
		_token = tokError;
}
int Input::Number()const
{
	assert(_token == tokNumber);
	return std::atoi(_buf);
}

运行效果
、

相关系列

小型计算器A small software project