curPos_：当前扫描到的位置； token_：当前扫描到的状态；
Scanner类方法如下： Number：扫描到数字，返回数字； Accept：扫描一个字符，登记当前的状态 Tocken：返回当前状态； SkipWhite：跳过空白； 表达式当前的状态如下：EToken是枚举量 扫描完毕； ERROR； 扫描到数字； 扫描到加号； 扫描到减号； 扫描到乘号； 扫描到除号； 扫描到左括号； 扫描到右括号； 扫描到变量的标识符；（后面再讲。。。）
注意枚举量的startUML画法：这里还补充的Scanner类和Parse的类图，UML只是表示类之间的关系，没必要把数据成员写的很清楚。
eg：将字符串3.5转换成一个double类型，且希望curPos_要移动到+号的位置，strtod第二个参数返回一个指针，移动到了+号的位置 P41\Scanner.h
#ifndef _SCANNER_H_ #define _SCANNER_H_ #include <string> enum EToken { TOKEN_END; TOKEN_ERROR; TOKEN_NUMBER; TOKEN_PLUS; TOKEN_MINUS; TOKEN_MULTIPLY; TOKEN_DIVIDE; TOKEN_LPARENTHESIS; TOKEN_RPARENTHESIS; TOKEN_IDENTIFIER; TOKEN_ASSIGN;//eg:a=5 }; //Scanner类：只负责扫描，并且登记当前的状态 class Scanner { public: Scanner(const std::string& buf); void Accept(); double Number() const; EToken Token() const; private: void SkipWhite(); const std:string buf_; unsigned int curPos_; EToken token_;//返回状态 double number_;//返回数字 }; #endif/*_SCANNER_H_*/P41\Scanner.cpp
#include "Scanner.h" #include <cctype> Scanner::Scan(const std::string& buf) : buf_(buf), curPos_(0) { Accept();//一个字符一个字符的扫描 } double Scanner::Number() const { return number_; } EToken Scanner::Token() const { return token_; } //忽略空白字符 void Scanner::SkipWhite() { while (isspace(buf_[curPos_])) ++curPos_; } void Scanner::Accept() { SkipWhite();//首先忽略空白字符 switch (buf_[curPos_]) { case '+': token_ = TOKEN_ADD; ++curPos_; break; case '-': token_ = TOKEN_MINUS; ++curPos_; break; case '*': token_ = TOKEN_MULTIPLY; ++curPos_; break; case '/': token_ = TOKEN_DIVIDE; ++curPos_; break; case '(': token_ = TOKEN_LPARENTHESIS; ++curPos_; break; case ')': token_ = TOKEN_RPARENTHESIS; ++curPos_; break; case '0': case '1': case '2' : case '3': case '4': case '5': case '6': case '7': case '8': case '9': case '.': token_ = TOKEN_NUMBER; char* p;//实际上这里的指针并没有指向 //buf_是一个字符串，buf_[curPos_]是一个字符，相当于得到了内部字符串的字符 //这里的指针p，指针变量p本身发送改变，也就是说它指向了其他地方，改变了指针的指向 number_ = strtod(&buf_[curPos_], &p);//返回第一个不是数字的位置 //将地址p转换为数字curPos_，用以更新curPos_ curPos_ = p - &buf[0];// &buf[0]是字符串的首地址 break; case '\0' : case '\n' : case '\r' : case EOF://认为表达式结束了 token_ = TOKEN_END; break; default: token_ = TOKEN_ERROR; break; } }P41\Parser.h
#ifndef _PARSER_H #define _PARSER_H //使用前向声明而不是包含Scanner的头文件的原因是，如果在cpp文件中多次包含了这样的头文件，使得生成的可执行文件增大 class Scanner; //Parser类：根据扫描结果，进行扫描，递归下降解析，直到生成一颗树 class Parser { public: Parser(Scanner& scanner); void Parse(); double Calculate() const; private: Scanner& scanner_; }; #endif /* _PARSER_H */P41\Parser.cpp
#include "Parser.h" #include "Scanner.h"//因为会使用到Scanner的一些接口进行扫描 //引用的初始化只能才初始化列表中进行初始化 Parser::Parser(Scanner& scanner) : scanner_(scanner) { } void Parser::Parse() { } //注意：带const的成员函数与不带const的成员函数可以构成重载 double Parser::Calculate() const { return 0.0; }P41\Node.h
#ifndef _NODE_H #define _NODE_H //（1）【采用】禁止对象拷贝的eg演示 //Noncopyable不能构造对象，因为构造对象没意义，仅仅用来继承 class Noncopyable { protected: Noncopyable() {}; ~Noncopyable() {}; private: Noncopyable(const Noncopyable&); const Noncopyable& operator=(const Noncopyable&); }; //用private继承的原因是：并没有继承Noncopyable类的接口，即：这不是接口继承，而是实现继承 //实现继承：仅仅利用基类的内部函数，仅仅能在派生类的内部使用，并不能成为派生类额接口 //Node变成了对象语义，因为：要构造Node，要先构造Noncopyable，而Noncopyable既不能拷贝构造，也不能赋值了 class Node : private Noncopyable { public: //每个节点都有一个计算的纯虚函数 //类Node用于多态，派生类都要实现Calc //Calc声明为const的，因为Calc不会改变类的成员 virtual double Calc() const = 0; //类Node是多态类，析构函数也要声明为虚析构函数，否则基类指针指向派生类对象， //通过基类指针释放对象的时候，是不会调用派生类的析构函数 virtual ~Node() {}; }; //NumerNode要实现这个纯虚函数Calc，为具体类；若没实现，还是抽象类 class NumberNode : public Node { public: NumberNode(double number) : number_(number) {} double Calc() const; private: const double number_;//加const的原因：因为number_初始化后就不会改变 }; //BinaryNode节点有2个子节点 //BinaryNode类没有实现Calc方法，BinaryNode类仍然是抽象类，只有它的派生类，加、减、乘、除节点才知道该如何计算 class BinaryNode : public Node { public: BinaryNode(Node* left, Node* right) : left_(left), right_(right) {} ~BinaryNode();//记得要释放left_和right_节点 protected: Node* const left_;//const的作用：指针不能改变（即指针不能指向其它的节点），而不是指针所指向的内容不能改变 Node* const right_; }; //于BinaryNode相比，它只有1个孩子 //UnaryNod也是抽象类，因为它没有实现Calc方法 class UnaryNode : public Node { public: UnaryNode(Node* child) : child_(child) {} ~UnaryNode(); protected: Node* child_; } //加法运算节点AddNode class AddNode : public BinaryNode { public: //构造函数初始化，要调用基类部分的构造函数 AddNode(Node* left, Node* right) : BinaryNode(left, right) {} //要实现Calc方法，AddNode类是具体类 double Calc() const; }; class SubNode : public BinaryNode { public: SubNode(Node* left, Node* right) : BinaryNode(left, right) {} double Calc() const; }; class MultiplyNode : public BinaryNode { public: MultiplyNode(Node* left, Node* right) : BinaryNode(left, right) {} double Calc() const; }; class DivideNode : public BinaryNode { public: DivideNode(Node* left, Node* right) : BinaryNode(left, right) {} double Calc() const; }; class UminusNode : public UnaryNode { public: UminusNode(Node* child) : UnaryNode(child) {} double Calc() const; }; #endif/* _NODE_H */P41\Node.cpp
#include "Node.h" #include <cmath.h> #include <iostream> //数字节点的计算方法就等于数字节点本身 double NumberNode::Calc() const { return number_; } BinaryNode::~BinaryNode() { delete left_; delete right_; } UnaryNode::~UnaryNode(); { delete child_; } double AddNode::Calc() const { //AddNode节点的值等于左计算节点得到的值+右计算节点得到的值 return left_->Calc() + right_->Calc(); } double SubNode::Calc() const { return left_->Calc() - right_->Calc(); } double MultiplyNode::Calc() const { return left_->Calc() * right_->Calc(); } double AddNode::Calc() const { double divisor = right_->Calc(); if (divisor != 0.0) return left_->Calc() / divisor; else { std::cout << "Error: Divisor by zero" <<std::endl; return HUGE_VAL; } } double UnaryNode::Calc() const { //孩子节点前面加一个负号,对照改进类继承体系的图看更好理解 return - child_->Calc(); }P41\main.cpp
#include <iostream> #include <string> #include "Scanner.h" #include "Parser.h" int main(void) { do { std::cout<<">"; std::string buffer; std::getline(std::cin, buffer);//输入一行表达式放到buf当中 Scanner scanner(buffer); Parser parser(scanner); parser.Parse();//实际上计算表达式的值，就是计算这颗树的根节点的值 paese.Calculate(); }while(1); return 0; }