20170225C++项目班03_parser实现/调试/

parser实现：

1：parser解析器，解析类和我们的扫面类是依赖的关系。解析类使用扫面类得到的信息来解析具体是什么节点（Node）。
2：扫面类每次都要使用到扫面类，没有扫面类就不行，他们最适合的就是依赖关系。
3：解析器里面要用到scanner，参数里面如果使用scanner的类对象，那么就需要在parser.h里面包含头文件，如果使用引用或者指针的话，可以只做前置申明就可以了，构造函数里面必须在初始化列表做scanner的赋值。从外部传递进来。
4：对外开放接口：parse();，来进行解析，还需要calc的接口，解析完成后就计算。下面为库文件的内容：

#ifndef PARSER_H_
#define PARSER_H_

namespace PoEdu {
class Scanner;
class Node;
class SymbolHelper;
class Parser
{
public:
Parser(Scanner &scanner);
~Parser();
void Parse();
double Calculate() const;
private:
Node* Expr();
Node* Term();
Node* Factor();
Scanner &scanner_;
SymbolHelper &symbol_hepler_;
Node *tree_;
};
}
#endif//!PARSER_H_

Parser调试：

1：每次等待用户输入的时候，可以输出一个>或者\等，这样看起来会比较好（逼格高）。
2：在还没把程序写好的情况下，尽量少考虑bug的问题，先把基本功能实现了，在很好的情况下可以正常运行之后在考虑修改bug的问题。
3：调试的技巧：在可能出bug的里面单步调试，在不符合预期执行效果的地方找逻辑错误（bug）。
4：当执行1-2+7的时候，我们会发现他会先执行2+7，然后1-9。因为我们使用的递归下降法目前还是右递归，默认从右边开始执行，需要解决。

解决右递归：

1：之所以会产生右结合是因为我们的表达式 = 项+表达式的时候，会默认地将后面的平级的运算符加上了括号，使他的优先级变高了。
2：解决方式：可以使用不同的算法实现左递归。我们使用平行复合Node来解决，将同一优先级的保存为一个复合Node，这个Node使用vector老保存，这种Node的Calc方法就是将里面保存的数据按从前往后执行，顺序执行求结果，这样将右递归变成了平行的复合Node来计算，这样解决起来也是比较简单的，而且会废弃原来的+-*/Node，直接使用复合Node。这样相当于是一个平行树。
    实现方式：使用两个vector分别保存平行树的NumberNode和对应的符号。Calc方法就取出里面的数据和符号进行运算，得出结果，后面的就和之前的思路一样。调用解析器的Calculate方法计算总结果。注意：即使只有一个+或者同级的运算符，也会使用平行复合Node，只不过里面只有一个数据和一个符号。
    还是使用复合类作为数据管理类，派生两个类分别用来实现+-优先级和*/优先级的处理。

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

namespace PoEdu {
Parser::Parser(Scanner& scanner, SymbolHelper &symbol_helper):scanner_(scanner),symbol_hepler_(symbol_helper)
{
}
Parser::~Parser()
{
}
void Parser::Parse()
{
tree_ = Expr();
}
double Parser::Calculate() const
{
return  tree_->Calc();
}
Node* Parser::Expr()
{
Node *node = Term();	//项 + 表达式
EToken token = scanner_.Token();
if(token == TOKEN_PLUS || token == TOKEN_MINUS)
{
MultipleNode *multipleNode = new SumNode(node);
do
{
scanner_.Accept();
Node *nextNode = Term();
multipleNode->AppendChild(nextNode, token == TOKEN_PLUS);
token = scanner_.Token();
}
while (token == TOKEN_PLUS || token == TOKEN_MINUS);
node = multipleNode;
}
else if(token == TOKEN_ASSIGN)
{
scanner_.Accept();
Node *nextNode = Expr();
node = new AssignNode(node, nextNode);
}
/*	if(token == TOKEN_PLUS)
{
scanner_.Accept();
Node *rightNode = Expr();
node = new AddNode(node, rightNode);

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

Node* Parser::Term()
{
Node *node = Factor();
EToken token = scanner_.Token();
if (token == TOKEN_MULTIPLY || token == TOKEN_DIVIDE)
{
MultipleNode *multipleNode = new ProductNode(node);
do
{
scanner_.Accept();
Node *nextNode = Factor();
multipleNode->AppendChild(nextNode, token == TOKEN_MULTIPLY);
token = scanner_.Token();
} while (token == TOKEN_MULTIPLY || token == TOKEN_DIVIDE);
node = multipleNode;
}
/*if (token == TOKEN_MULTIPLY)
{
scanner_.Accept();
Node *rightNode = Term();
node = new MultipNode(node, rightNode);
}
else if (token == TOKEN_DIVIDE)
{
scanner_.Accept();
Node *rightNode = Term();
node = new DivisionNode(node, rightNode);
}*/
return node;
}

Node* Parser::Factor()
{
//（（1 + 2） * 3 + 4） / 5

Node *node = nullptr;
EToken token = scanner_.Token();
if(token == TOKEN_LPARENTEESES)
{
scanner_.Accept();
node = Expr();
if(scanner_.Token() == TOKEN_RPARENTEESES)
scanner_.Accept();
else
std::cout << "缺少右括弧" << std::endl;	//异常
}
else if(token == TOKEN_NUMBER)
{
node = new NumberNode(scanner_.NumBer());
scanner_.Accept();
}
else if(token == TOKEN_IDENTIFIER)
{
std::string symbol = scanner_.Symbol();
unsigned int id = symbol_hepler_.FindSymbol(symbol);
if(id == 0xFFFFFFFF)
{
id = symbol_hepler_.AddSymbol(symbol);
}
node = new VariableNode(id, symbol_hepler_.GetStorage());
scanner_.Accept();
}
else if(token == TOKEN_MINUS)
{
scanner_.Accept();
node = new MinusNode(Factor());
}
return node;
}
}

讲解：

一个函数=default代表这个函数就和默认函数一样。
auto：自动类型推导。