44 c++ m面向对象版表达式计算器 设计缺陷

8-2+1 实际上等于7 ，运行是5，右结合的

当前是表达式=项+- 一个表达式  这里8 是一个项，- 后面是一个表达式。所以右结合了。

这样设计之后，很多类都没有用了。

优化后：

Node.h

#ifndef _NODE_H_
#define _NODE_H_
#include <vector>
#include <iostream>
using namespace std;
class Noncopyable{
protected:
	Noncopyable(){};
	~Noncopyable(){};
private:
	Noncopyable(const Noncopyable&);
	const Noncopyable& operator=(const Noncopyable&);
};

//把Node 类变为对象语义  private 继承因为，因为Noncopyable 没有任何接口，是实现继承
class Node:private Noncopyable
{
public:
	virtual double Calc() const=0;//纯虚函数
	virtual ~Node(){};
};
class NumberNode:public Node
{
public:
	double Calc() const;
	NumberNode(double number):number_(number){};
private:
	const double number_;//一经过初始化就不会改变
};
class BinaryNode:public Node
{
public:
	BinaryNode(Node* left,Node* right):left_(left),right_(right)
	{
	}
	~BinaryNode();

	//这里没有实现Calc 方法意味着还是抽象类  不懂如何计算


protected:
	Node* const left_;//一经初始化也不会改变  指针不能改变
	Node* const right_;
};
class UnaryNode:public Node
{
public:
	UnaryNode(Node* child):child_(child)
	{
	}
	~UnaryNode();
protected:
	Node* const child_;
};
/*class AddNode:public BinaryNode
{
public:
	AddNode(Node* left,Node* right):BinaryNode(left,right)
	{
	}
private:
	double Calc() const;
};
class SubNode:public BinaryNode
{
public:
	SubNode(Node* left,Node* right):BinaryNode(left,right)
	{
	}
private:
	double Calc() const;
};
class MultiplyNode:public BinaryNode
{
public:
	MultiplyNode(Node* left,Node* right):BinaryNode(left,right)
	{
	}
private:
	double Calc() const;
};
class DivideNode:public BinaryNode
{
public:
	DivideNode(Node* left,Node* right):BinaryNode(left,right)
	{
	}
private:
	double Calc() const;
}*/;
class UMInusNode:public UnaryNode
{
public:
	UMInusNode(Node* child):UnaryNode(child)
	{
	}
private:
	double Calc() const;
};
class MultipleNode:public Node
{
public:
	//在解析的时候只能确定一个节点，把它放进来。子节点的第一个节点
	//没有实现Calc 方法，目前还是抽象类
	MultipleNode(Node* node)
	{
		//即使第一个节点是负的，添加的时候也是正的。
		AppendChild(node,true);
	}
	//往节点中添加子节点 确定正负性。
	void AppendChild(Node* node,bool positive)
	{
		childs_.push_back(node);
		positives_.push_back(positive);
	}
	~MultipleNode();
protected:
		//有很多的子代 放到vector 中。
	vector<Node*> childs_;
	    //节点的正负性。
	vector<bool> positives_;
};
class SumNode:public MultipleNode{
public:
	SumNode(Node* node):MultipleNode(node)
	{
	
	}
	double Calc() const;
};
class ProductNode:public MultipleNode{
public:
	ProductNode(Node* node):MultipleNode(node)
	{
	
	}
	double Calc() const;
};
#endif

Node.cpp

#include "Node.h"
using namespace std;
#include <iostream>
#include <cmath>
#include <cassert>
double NumberNode::Calc() const
{
	return number_;
}
BinaryNode::~BinaryNode()
{
	delete left_;
	delete right_;
}
UnaryNode::~UnaryNode()
{
    delete child_;
}
//double AddNode::Calc() const
//{
//	return left_->Calc()+right_->Calc();
//}
//double SubNode::Calc() const
//{
//	return left_->Calc()-right_->Calc();
//}
//double MultiplyNode::Calc() const
//{
//	return left_->Calc()*right_->Calc();
//}
//double DivideNode::Calc() const
//{
//	double divisor=right_->Calc();
//	if(divisor!=0)
//	{
//		return left_->Calc()/divisor;
//	}else{
//		cout<<"erro : diviso by zero"<<endl;
//		return HUGE_VAL;
//	}
//	
//}
double UMInusNode ::Calc() const
{
	return -child_->Calc();
}
MultipleNode ::~MultipleNode()
{
	vector<Node*>::const_iterator it;
	for(it=childs_.begin();it!=childs_.end();++it)
	{
		delete *it;
	}
}
double SumNode::Calc() const
{
	double result=0.0;
	vector<Node*>::const_iterator childIt=childs_.begin();
	vector<bool>::const_iterator positiveIt=positives_.begin();
	for(;childIt!=childs_.end();++childIt,++positiveIt)
	{
		assert(positiveIt!=positives_.end());
		double var=(*childIt)->Calc();
		if(*positiveIt){
			result+=var;
		}else{
			result-=var;
		}
	}
	assert(positiveIt==positives_.end());
	return result;
}
double ProductNode::Calc() const
{
	double result=1.0;
	vector<Node*>::const_iterator childIt=childs_.begin();
	vector<bool>::const_iterator positiveIt=positives_.begin();
	for(;childIt!=childs_.end();++childIt,++positiveIt)
	{
		assert(positiveIt!=positives_.end());
		double var=(*childIt)->Calc();
		if(*positiveIt){
			result*=var;
		}else if(var!=0.0){
		    result/=var;
		}else {
			cout<<"Div by zero"<<endl;
			return HUGE_VAL;
		}
	}
	assert(positiveIt==positives_.end());
	return result;
}

parser.h 没变

#ifndef _PARSER_H_
#define _PARSER_H_
class Scanner;
class Node;//前项声明
enum STATUS{
	STATUS_OK,
	
	STATUS_ERROR,

	STATUS_QUIT
};
class Parser
{
	//这里是引用的方式来使用Scanner 或者指针的方式，没有必要这么快就包含头文件，可以用前项声明。
	//这样的话，头文件会比较小，cpp 中多次包含了，就会使得可执行文件增大
public:
	Parser(Scanner& scanner);
	void Parse();
	Node* Expr();//表达式
	Node* Term();//项
	Node* Factory();//因式
	double Calculate() const;
private:
	Scanner& scanner_;
	Node* tree_;//生成一棵表达式树
	STATUS status_;
};
#endif

parser.cpp

#include "Parser.h"
#include "Scanner.h"
#include "Node.h"
#include <cassert>
#include <iostream>

//引用在初始化列表中进行初始化
Parser::Parser(Scanner& scanner):scanner_(scanner),tree_(0)//0 就是null
{

}
void Parser::Parse()
{
	tree_=Expr();//解析是否是一个表达式  返回一个Node
}
Node* Parser::Expr()
{
	Node* node=Term();
	EToken token=scanner_.Token();//当前扫描器的状态
	//if(token==TOKEN_PLUS)
	//{
	//	scanner_.Accept();//如果扫描加号 接收 加号  为了扫描下一个字符
	//	Node* nodeRight=Expr();
	//	node=new AddNode(node,nodeRight);

	//}else if(token==TOKEN_MINUS)
	//{
	//	scanner_.Accept();
	//	Node* nodeRight=Expr();
	//	node=new SubNode(node,nodeRight);

	//}
	if(token==TOKEN_PLUS||token==TOKEN_MINUS)
	{
		//如果是+- 新建节点
		//Expr:=Term {('+'|'-')Term}
		MultipleNode* multipleNode=new SumNode(node);
		//SumNode 的第一个节点实际上是前一个项，总是把它当作一个正数
		//子节点有多个所以用循环
		do{
			scanner_.Accept();
			Node* nextNode=Term();
			multipleNode->AppendChild(nextNode,(token==TOKEN_PLUS));
			token=scanner_.Token();
		}while(token==TOKEN_PLUS||token==TOKEN_MINUS);
		node=multipleNode;
	}
	return node;
}
Node* Parser::Factory()
{
	Node* node=0;
	EToken token=scanner_.Token();
	if(token==TOKEN_LPARENTHESIS)//左括号
	{
		scanner_.Accept();//指针下移动 accept'('
		node=Expr();
		if(scanner_.Token()==TOKEN_RPARENTHESIS)
		{
			scanner_.Accept();//accept ')'

		}else
		{
			status_=STATUS_ERROR;
			//Todo:抛出异常
			cout<<"not a valid experssion"<<endl;
			node=0;
		}
	}else if(token==TOKEN_NUMBER)
	{
		node=new NumberNode(scanner_.Number());
		scanner_.Accept();
	}else if(token==TOKEN_MINUS)
	{
		scanner_.Accept();//accept minus 负号
		node=new UMInusNode(Factory());
	}else
	{
		status_=STATUS_ERROR;
		//Todo:抛出异常
			cout<<"not a valid experession"<<endl;
			node=0;
	}
	return node;
}
Node* Parser::Term()
{
	Node* node=Factory();
	EToken token=scanner_.Token();
	/*if(token==TOKEN_MULTIPLY)
	{
		scanner_.Accept();
		Node* nodeRight=Term();
		node=new MultiplyNode(node,nodeRight);
	}else if(token==TOKEN_DIVIDE)
	{
		scanner_.Accept();
		Node* nodeRight=Term();
		node=new DivideNode(node,nodeRight);

	}*/
	if(token==TOKEN_MULTIPLY||token==TOKEN_DIVIDE)
	{
		//如果是+- 新建节点
		//Term:=Factory {('*'|'/')Factory}
		MultipleNode* multipleNode=new ProductNode(node);
		//SumNode 的第一个节点实际上是前一个项，总是把它当作一个正数
		//子节点有多个所以用循环
		do{
			scanner_.Accept();
			Node* nextNode=Factory();
			multipleNode->AppendChild(nextNode,(token==TOKEN_MULTIPLY));
			token=scanner_.Token();
		}while(token==TOKEN_MULTIPLY||token==TOKEN_DIVIDE);
		node=multipleNode;
	}
	return node;
}
//加const 和不加const 是可以构成重载的。
double Parser::Calculate() const
{
	assert(tree_!=0);
	return tree_->Calc();
}