正则表达式：
正则表达式是当前主流的字符串识别机制之一，另外一种是文法识别。
和文法相比，正则表达式具有构造相对简单，运行效率较高的特点，所以一般的字符串识别会使用正则表达式。
正则表达式有三种主要运算符是我们在构造词法分析器生成器LEX需要用到的：*、|、连接
*代表闭包运算，假如有一个字符串a，那么a*就代表由任意个字符串a组合成的字符串，包括空串（0个字符串a组合成的字符串），如
*={空串,a,aa,aaa.....}
|代表或运算，不同于*闭包运算，|是针对两个字符串的，假如有两个字符串a和b，a|b就代表可能是字符串a也可能是字符串b的字符串，如
(a|b)={a,b}
连接运算在龙书中的表述是两个字符串紧凑在一起，假如有两个字符串a和b，连接的写法是ab。不过为了代码实现方便，可以写成a
b,a-b,a#b等等都可以，只需要在代码实现中更改相关字符即可。假设写法是a-b，那么a-b表示的集合是前面是字符串a，后面是字符串b的字符串。如
a-b={ab}
有穷自动机：
有穷自动机本质上是一个基于状态转换图的模型，属于状态机模型中的一种，它的应用十分广泛，但是这里我们只考虑识别字符串的情况。有穷自动机分两种，一种是不确定有穷自动机NFA，一种是确定有穷自动机DFA，两者的主要差别是NFA里面的状态转换图可以存在不需要花费任何代价就能跳转的边，而且允许出现重复代价的边，这都将导致很多问题出现，这里不做深入研究。
将一个字符串输入有穷自动机，有穷自动机则会输出一个bool值来表示这个字符串是否与有穷自动机所表示的字符串匹配。当然，有穷自动机还可以做成输出数值的形式，这样就可以用一个有穷自动机识别很多种字符串，比如输出0表示识别失败，输出1表示整数，输出2表示浮点数，输出3表示C++中的标识符等等。
状态转换图有若干条单向边和若干个节点，节点代表状态，边上的权值代表从起始状态到目标状态所需要花费的代价。
上面的图是表示玩家控制角色的一个基本状态转换图，有空闲，攻击，受击和死亡四个状态，每当满足当前状态的某条边的代价时，角色的状态就会从当前状态跳转到这条边指向的状态。
比如，空闲状态有一条边指向攻击状态，这条边的代价是玩家按下A键，那么如果玩家的角色处于空闲状态，而玩家又按下了A键，那么玩家的角色将会进入攻击状态。而攻击状态有一条边指向受击状态，代价是怪物攻击到了玩家，那么假如玩家的角色在攻击状态，被怪物攻击时，玩家的角色就会进入到受击状态。这条边体现出来的游戏效果是，玩家的攻击是可以被打断的。除此之外，很容易看到受击状态没有一条边直接指向攻击状态，这说明当玩家的角色被攻击的时候，玩家的角色是不能攻击敌人的，这样就会体现出游戏中的角色的”僵直”效果。
Bool值有穷自动机的原理是，输入一个代价序列，根据这个序列和状态转换图不断跳转状态，看看最终这个序列会不会到达接受态，如果会，那么就输出true，否则输出false。
以上面那个状态转换图为例，假设接受态是死亡状态，那么这个有穷自动机就是用于判断是否玩家角色死亡的。
对于这样一个动作输入序列<按下A键，怪物攻击，血量清空>
从开始的空闲状态，首先会因为”按下A键”跳转到攻击状态，然后因为”怪物攻击”跳转到受击状态，最后因为”血量清空”而跳转到死亡状态。至此，三个动作序列全部输入完成，此时有穷自动机会检查当前状态是否是接受态，检查发现当前是死亡状态，于是有穷自动机输出true。这体现出来的游戏效果是，当玩家攻击时，怪物攻击玩家可以打断玩家的攻击，并使玩家受伤，如果玩家伤势过重，血量清空，则会死亡。
对于这样一个动作输入序列<按下A键，怪物攻击，攻击结束>
从开始的空闲状态，首先会因为”按下A键”跳转到攻击状态，然后因为”怪物攻击”跳转到受击状态，最后因为”攻击结束”而跳转到空闲状态。所有动作序列完成后，有穷自动机发现当前状态(空闲状态)不是接受态，于是输出false。这体现出来的游戏效果是，当玩家攻击时，怪物攻击玩家可以打断玩家的攻击，并使玩家受伤，然而玩家的血量直到怪物攻击结束也没有清空，那么玩家就不会死亡。
对于这样一个动作输入序列<按下A键，血量清空>
从开始的空闲状态，首先会因为”按下A键”跳转到攻击状态，然而攻击状态没有代价为”血量清空”的边，所以攻击状态不会发生任何跳转，于是仍然保持攻击状态。这样两个动作执行完后，有穷自动机发现当前状态(攻击状态)不是接受态，所以输出false。体现出来的游戏效果是，不可能出现玩家按下A键，发动攻击，然后玩家的血量反而会清空的情况。
从正则表达式到有穷自动机：
由于NFA的效率差，问题多，这里我们应当选用DFA来构造有穷自动机。有些人可能在学编译原理这门课程时，老师总是要求你先把正则表达式转化为NFA，在把NFA转化为DFA，最后把DFA最小化。这都是考试的套路，一方面是因为很多情况下NFA能更精确的描述问题模型，如果不考NFA，那么绝大多数小伙伴是绝对不会去看的......另一方面是因为，龙书对于很多同学来说还是比较晦涩难懂的，NFA可以多一个送分点，少一点挂科率，免得学生到时候又去打扰老师......
不过既然我们现在是实干，当然不能死板的按照考试的套路去做，那样会花费大量时间到不实用的工作中去。我们直接根据正则表达式来构造DFA。
我们对我们使用的正则表达式定义这样的规则(你可以根据自己的喜好更改名称)：
"letter"代表英文字母
"digit"代表数字
"_"代表字符下划线
"."代表小数点
对于单个字符而言，可以类似下划线和小数点那样直接用本来的字符表示。
因此我们根据我们以上定义的规则定义如下正则表达式：
(1)digit*; 整数
(2)(digit*)-.-(digit*); 实数
(3)(letter|_)-((letter|_|digit)*); 超过一个字符的C++标识符
(4)letter|_; 只有一个字符的C++标识符
为什么C++的标识符正则表达式会有两个呢？
这是因为DFA里面没有代价为空的边，所以在这里执行*闭包操作不允许包含空串的情况，所以第三个表达式不能包含后面的((letter|_|digit)*)为空串的情况，为此我们可以添加第四个正则表达式。
为什么要加括号呢？
这是因为之前我们所定义的三种运算符是没有优先级区别的，只有左结合的运算优先级，这样是无法满足我们的表达需求的，所以我们需要加括号。
怎么加括号呢？
你只需要保证，在同一层内的从左到右的运算满足你的需求即可，不满足则给你想要优先运算的地方加上括号。
下面，我们来根据这些表达式一步步构造DFA：
(A)构造第一个DFA：
对于第一个表达式digit*，我们先行构造出digit的DFA，然后在对digit的DFA进行闭包运算。
我们不管龙书上是怎么表示的，为了代码实现方便，我们设定每个DFA都有至少有两个状态节点,开始状态start和接受状态end。
那么digit的DFA可以构造成这样
然后，我们需要进行*闭包运算，闭包运算在NFA中是添加一条从接受态到开始态的无代价边。而在DFA中，*闭包运算是将结束态和开始态进行合并。对于上面的DFA，执行闭包运算得到的digit*的DFA如下：
现在我们来看看|或运算，或运算的本质是把两个DFA的开始状态和接受态分别合并，假设我们现在构造letter|_的DFA，也就是第四个表达式。
我们再来看看-连接运算，-连接运算的本质是把第一个DFA的接受态和第二个DFA的开始态合并，然后把第二个DFA的接受态作为整个合并DFA的接受态。
假设我们现在构造letter-digit的DFA
根据表达式如此这般地构造DFA，即可将正则表达式直接转化成DFA。
下面是正则表达式到DFA的代码实现：
我们设计这样两个类来制作DFA。
class state {
public:
//标识接受态的bool变量
bool isAccept;
//标识当前状态的访问性，状态的访问性与状态转换图的访问性一致，方可访问
bool visitable;
//该链表用于存储当前状态所指向的状态
DragonList<state*> next;
//该链表用于存储当前状态跳转到对应状态所需的代价
DragonList<string> price;
state();
};
class DFA {
public:
//标识当前状态转换图的访问性，状态的访问性与状态转换图的访问性一致，方可访问
bool visitable;
//状态转换图的开始状态
state* start;
//状态转换图的接受状态
state* end;
/*构造一个DFA的构造函数，该构造函数将可以构造一个拥有两个节点和
一条代价为参数1的边。
*/
DFA(string str);
//将另外一个DFA加入到当前的DFA中，参数1为被加入的DFA，参数2为运算符
void addDFA(DFA* dfa, const char op);
//重定向函数，将原本指向end的状态改为指向其他状态
void resumeEnd(state* s, state* newEnd);
};
这两个类设计的难点在于addDFA函数和resumeEnd函数，从注释上看，addDFA函数是用来合并DFA的。实际上，addDFA函数的内部也调用的resumeEnd函数。我们先来探讨一下如何实现正则表达式的三种运算。
首先是*闭包运算，上面提到，闭包运算是合并接受态和开始态。怎么样算合并呢？直接赋值显然是不行的。如果直接把end赋值给start那么start所有的边都将会丧失掉，整个DFA就毁了。而如果我们在赋值之前，先把start的所有边加到end里面去，再赋值，这样就会无损的实现接受态和开始态的合并。因为在合并后的状态节点新的Start里面，包含了旧的start和旧的end的所有边。
然后是|或运算，和闭包运算一样，上面提到的需要把两个DFA的开始态和接受态进行合并。可以采用同样的机理进行合并。最后的-连接运算也是如此。
void DFA::addDFA(DFA* dfa, const char op)
{
if (op == ‘*‘) {
resumeEnd(start, start);
end = start;
start->isAccept = true;
}
else if (op == ‘ ‘) {
auto nn = dfa->start->next.root;
auto pn = dfa->start->price.root;
while (nn != nullptr) {
end->next.add(nn->data);
end->price.add(pn->data);
nn = nn->next;
pn = pn->next;
}
end->isAccept = false;
end = dfa->end;
}
else if (op == ‘|‘) {
auto nn = dfa->start->next.root;
auto pn = dfa->start->price.root;
while (nn != nullptr) {
start->next.add(nn->data);
start->price.add(pn->data);
nn = nn->next;
pn = pn->next;
}
resumeEnd(start, dfa->end);
end = dfa->end;
}
visitable = !visitable;
}
void DFA::resumeEnd(state* s, state* newEnd)
{
if (!s) return;
for (auto n = s->next.root; n != nullptr; n = n->next) {
if (n->data == end) {
n->data = newEnd;
}
if (n->data != nullptr&&n->data->visitable == visitable) {
n->data->visitable = !visitable;
resumeEnd(n->data, newEnd);
}
}
}
理解这两个类的功能之后，我们正式开始构造DFA。
首先，我们需要先从文本中读入正则表达式。实现很容易，可以跳过。
void readExpression(const string filename) {
ifstream fin;
fin.open(filename);
if (fin.fail()) {
cout << "文件打开失败！" << endl;
system("pause");
exit(1);
}
string expression = "";
while (!fin.fail()) {
char ch = char(fin.get());
if (ch == ‘;‘) {
elis.add(expression);
expression = "";
continue;
}
expression = expression + ch;
}
fin.close();
}
以上代码中，elis是LEX程序的一个成员，它是一个链表，用于保存那些已经被读入的正则表达式。
接下来，我们就需要对表达式进行字符串解析了，哪些字符串是可以构造DFA的符号，哪些字符串是操作符。此时需要特别注意，括号及括号里面的内容应当被当做一个可构造DFA的符号来处理。需要括号里面内容的DFA时再来进行构造。
比如正则表达式：(letter|_)-((letter|_|digit)*);
在最开始处理这个表达式时，可以这样处理
令A1=letter|_ ,A2=(letter|_|digit)*
那么，我们构造的DFA将是
DFA=A1的DFA - A2的DFA，表达式也变成了(A1)-(A2)
可构造DFA的符号序列是：<A1,A2>
操作符序列是：<->
但是现在A1的DFA和A2的DFA我们不知道啊，我们实际上也不能直接根据一串表达式构造DFA，所以我们需要先去一步步构造A1和A2的DFA。
而A1的表达式是letter|_。
可构造DFA的符号序列是：<letter,_>
操作符序列是：<|>
所以我们可以先构造一个letter的DFA和一个-的DFA，然后再按照操作符序列将两者进行合并。可以这样写代码：
auto d1=new DFA(“letter”);
Auto d2=new DFA(“-”);
d1->addDFA(d2,’|’);
构造完A1的DFA之后，再去构造A2的DFA即可。做到这里的小伙伴很容易发现这里面是存在递归关系，所以这个构造DFA的函数应该采用递归的形式来编写。
DFA* createDFA(const string expression) {
//该链表用于保存表达式中各个符号生成DFA
DragonList<DFA*>* dlis = new DragonList<DFA*>();
//该链表用于保存表达式中的符号序列
DragonList<string>* slis = extractSymbol(expression);
//该链表用于保存表达式中的操作符序列
DragonList<char>* olis = extractOperator(expression);
//遍历符号链表
for (auto s = slis->root; s != nullptr; s = s->next) {
string str = s->data;
//如果某个符号里面带有括号，则需要递归的先行构造这个符号的子DFA
if (str[0] == ‘(‘) {
//剥离括号
str = str.substr(1,str.length()-2);
//递归调用createDFA函数，获取DFA
auto d = createDFA(str);
//将获取的DFA加入到DFA序列中
dlis->add(d);
continue;
}
//程序到这里说明当前符号是不带括号的，是可以直接构造DFA的符号
//查询已知的可构造符号列表，并构造DFA
for (int i = 0; i < symLen; i++) {
if (str == symbol[i]) {
auto d = new DFA(symbol[i]);
dlis->add(d);
}
}
}
//将DFA序列按照操作符序列进行合并，然后返回合并后的DFA
return mergeDFA(dlis, olis);
}
//将一个DFA序列按照一个操作符序列进行合并，得到一个DFA
DFA* mergeDFA(DragonList<DFA*>* dlis, DragonList<char>* olis)
{
//获取DFA序列中的第一个DFA作为初始DFA
DFA* d = dlis->root->data;
//获取DFA序列中的第一个DFA，用于遍历
auto dn = dlis->root;
//遍历操作符序列，进行合并
for (auto op = olis->root; op != nullptr; op = op->next) {
//如果操作符不是单目操作符，则需要使dn指向下一个DFA
if (op->data != ‘*‘) dn = dn->next;
if (dn == nullptr) break;
d->addDFA(dn->data, op->data);
}
return d;
}
至此，我们就能根据文本中的正则表达式来构建DFA了。
正则表达式：
正则表达式是当前主流的字符串识别机制之一，另外一种是文法识别。
和文法相比，正则表达式具有构造相对简单，运行效率较高的特点，所以一般的字符串识别会使用正则表达式。
正则表达式有三种主要运算符是我们在构造词法分析器生成器LEX需要用到的：*、|、连接
*代表闭包运算，假如有一个字符串a，那么a*就代表由任意个字符串a组合成的字符串，包括空串（0个字符串a组合成的字符串），如
*={空串,a,aa,aaa.....}
|代表或运算，不同于*闭包运算，|是针对两个字符串的，假如有两个字符串a和b，a|b就代表可能是字符串a也可能是字符串b的字符串，如
(a|b)={a,b}
连接运算在龙书中的表述是两个字符串紧凑在一起，假如有两个字符串a和b，连接的写法是ab。不过为了代码实现方便，可以写成a
b,a-b,a#b等等都可以，只需要在代码实现中更改相关字符即可。假设写法是a-b，那么a-b表示的集合是前面是字符串a，后面是字符串b的字符串。如
a-b={ab}
有穷自动机：
有穷自动机本质上是一个基于状态转换图的模型，属于状态机模型中的一种，它的应用十分广泛，但是这里我们只考虑识别字符串的情况。有穷自动机分两种，一种是不确定有穷自动机NFA，一种是确定有穷自动机DFA，两者的主要差别是NFA里面的状态转换图可以存在不需要花费任何代价就能跳转的边，而且允许出现重复代价的边，这都将导致很多问题出现，这里不做深入研究。
将一个字符串输入有穷自动机，有穷自动机则会输出一个bool值来表示这个字符串是否与有穷自动机所表示的字符串匹配。当然，有穷自动机还可以做成输出数值的形式，这样就可以用一个有穷自动机识别很多种字符串，比如输出0表示识别失败，输出1表示整数，输出2表示浮点数，输出3表示C++中的标识符等等。
状态转换图有若干条单向边和若干个节点，节点代表状态，边上的权值代表从起始状态到目标状态所需要花费的代价。
上面的图是表示玩家控制角色的一个基本状态转换图，有空闲，攻击，受击和死亡四个状态，每当满足当前状态的某条边的代价时，角色的状态就会从当前状态跳转到这条边指向的状态。
比如，空闲状态有一条边指向攻击状态，这条边的代价是玩家按下A键，那么如果玩家的角色处于空闲状态，而玩家又按下了A键，那么玩家的角色将会进入攻击状态。而攻击状态有一条边指向受击状态，代价是怪物攻击到了玩家，那么假如玩家的角色在攻击状态，被怪物攻击时，玩家的角色就会进入到受击状态。这条边体现出来的游戏效果是，玩家的攻击是可以被打断的。除此之外，很容易看到受击状态没有一条边直接指向攻击状态，这说明当玩家的角色被攻击的时候，玩家的角色是不能攻击敌人的，这样就会体现出游戏中的角色的”僵直”效果。
Bool值有穷自动机的原理是，输入一个代价序列，根据这个序列和状态转换图不断跳转状态，看看最终这个序列会不会到达接受态，如果会，那么就输出true，否则输出false。
以上面那个状态转换图为例，假设接受态是死亡状态，那么这个有穷自动机就是用于判断是否玩家角色死亡的。
对于这样一个动作输入序列<按下A键，怪物攻击，血量清空>
从开始的空闲状态，首先会因为”按下A键”跳转到攻击状态，然后因为”怪物攻击”跳转到受击状态，最后因为”血量清空”而跳转到死亡状态。至此，三个动作序列全部输入完成，此时有穷自动机会检查当前状态是否是接受态，检查发现当前是死亡状态，于是有穷自动机输出true。这体现出来的游戏效果是，当玩家攻击时，怪物攻击玩家可以打断玩家的攻击，并使玩家受伤，如果玩家伤势过重，血量清空，则会死亡。
对于这样一个动作输入序列<按下A键，怪物攻击，攻击结束>
从开始的空闲状态，首先会因为”按下A键”跳转到攻击状态，然后因为”怪物攻击”跳转到受击状态，最后因为”攻击结束”而跳转到空闲状态。所有动作序列完成后，有穷自动机发现当前状态(空闲状态)不是接受态，于是输出false。这体现出来的游戏效果是，当玩家攻击时，怪物攻击玩家可以打断玩家的攻击，并使玩家受伤，然而玩家的血量直到怪物攻击结束也没有清空，那么玩家就不会死亡。
对于这样一个动作输入序列<按下A键，血量清空>
从开始的空闲状态，首先会因为”按下A键”跳转到攻击状态，然而攻击状态没有代价为”血量清空”的边，所以攻击状态不会发生任何跳转，于是仍然保持攻击状态。这样两个动作执行完后，有穷自动机发现当前状态(攻击状态)不是接受态，所以输出false。体现出来的游戏效果是，不可能出现玩家按下A键，发动攻击，然后玩家的血量反而会清空的情况。
从正则表达式到有穷自动机：
由于NFA的效率差，问题多，这里我们应当选用DFA来构造有穷自动机。有些人可能在学编译原理这门课程时，老师总是要求你先把正则表达式转化为NFA，在把NFA转化为DFA，最后把DFA最小化。这都是考试的套路，一方面是因为很多情况下NFA能更精确的描述问题模型，如果不考NFA，那么绝大多数小伙伴是绝对不会去看的......另一方面是因为，龙书对于很多同学来说还是比较晦涩难懂的，NFA可以多一个送分点，少一点挂科率，免得学生到时候又去打扰老师......
不过既然我们现在是实干，当然不能死板的按照考试的套路去做，那样会花费大量时间到不实用的工作中去。我们直接根据正则表达式来构造DFA。
我们对我们使用的正则表达式定义这样的规则(你可以根据自己的喜好更改名称)：
"letter"代表英文字母
"digit"代表数字
"_"代表字符下划线
"."代表小数点
对于单个字符而言，可以类似下划线和小数点那样直接用本来的字符表示。
因此我们根据我们以上定义的规则定义如下正则表达式：
(1)digit*; 整数
(2)(digit*)-.-(digit*); 实数
(3)(letter|_)-((letter|_|digit)*); 超过一个字符的C++标识符
(4)letter|_; 只有一个字符的C++标识符
为什么C++的标识符正则表达式会有两个呢？
这是因为DFA里面没有代价为空的边，所以在这里执行*闭包操作不允许包含空串的情况，所以第三个表达式不能包含后面的((letter|_|digit)*)为空串的情况，为此我们可以添加第四个正则表达式。
为什么要加括号呢？
这是因为之前我们所定义的三种运算符是没有优先级区别的，只有左结合的运算优先级，这样是无法满足我们的表达需求的，所以我们需要加括号。
怎么加括号呢？
你只需要保证，在同一层内的从左到右的运算满足你的需求即可，不满足则给你想要优先运算的地方加上括号。
下面，我们来根据这些表达式一步步构造DFA：
(A)构造第一个DFA：
对于第一个表达式digit*，我们先行构造出digit的DFA，然后在对digit的DFA进行闭包运算。
我们不管龙书上是怎么表示的，为了代码实现方便，我们设定每个DFA都有至少有两个状态节点,开始状态start和接受状态end。
那么digit的DFA可以构造成这样
然后，我们需要进行*闭包运算，闭包运算在NFA中是添加一条从接受态到开始态的无代价边。而在DFA中，*闭包运算是将结束态和开始态进行合并。对于上面的DFA，执行闭包运算得到的digit*的DFA如下：
现在我们来看看|或运算，或运算的本质是把两个DFA的开始状态和接受态分别合并，假设我们现在构造letter|_的DFA，也就是第四个表达式。
我们再来看看-连接运算，-连接运算的本质是把第一个DFA的接受态和第二个DFA的开始态合并，然后把第二个DFA的接受态作为整个合并DFA的接受态。
假设我们现在构造letter-digit的DFA
根据表达式如此这般地构造DFA，即可将正则表达式直接转化成DFA。
下面是正则表达式到DFA的代码实现：
我们设计这样两个类来制作DFA。
class state {
public:
//标识接受态的bool变量
bool isAccept;
//标识当前状态的访问性，状态的访问性与状态转换图的访问性一致，方可访问
bool visitable;
//该链表用于存储当前状态所指向的状态
DragonList<state*> next;
//该链表用于存储当前状态跳转到对应状态所需的代价
DragonList<string> price;
state();
};
class DFA {
public:
//标识当前状态转换图的访问性，状态的访问性与状态转换图的访问性一致，方可访问
bool visitable;
//状态转换图的开始状态
state* start;
//状态转换图的接受状态
state* end;
/*构造一个DFA的构造函数，该构造函数将可以构造一个拥有两个节点和
一条代价为参数1的边。
*/
DFA(string str);
//将另外一个DFA加入到当前的DFA中，参数1为被加入的DFA，参数2为运算符
void addDFA(DFA* dfa, const char op);
//重定向函数，将原本指向end的状态改为指向其他状态
void resumeEnd(state* s, state* newEnd);
};
这两个类设计的难点在于addDFA函数和resumeEnd函数，从注释上看，addDFA函数是用来合并DFA的。实际上，addDFA函数的内部也调用的resumeEnd函数。我们先来探讨一下如何实现正则表达式的三种运算。
首先是*闭包运算，上面提到，闭包运算是合并接受态和开始态。怎么样算合并呢？直接赋值显然是不行的。如果直接把end赋值给start那么start所有的边都将会丧失掉，整个DFA就毁了。而如果我们在赋值之前，先把start的所有边加到end里面去，再赋值，这样就会无损的实现接受态和开始态的合并。因为在合并后的状态节点新的Start里面，包含了旧的start和旧的end的所有边。
然后是|或运算，和闭包运算一样，上面提到的需要把两个DFA的开始态和接受态进行合并。可以采用同样的机理进行合并。最后的-连接运算也是如此。
void DFA::addDFA(DFA* dfa, const char op)
{
if (op == ‘*‘) {
resumeEnd(start, start);
end = start;
start->isAccept = true;
}
else if (op == ‘ ‘) {
auto nn = dfa->start->next.root;
auto pn = dfa->start->price.root;
while (nn != nullptr) {
end->next.add(nn->data);
end->price.add(pn->data);
nn = nn->next;
pn = pn->next;
}
end->isAccept = false;
end = dfa->end;
}
else if (op == ‘|‘) {
auto nn = dfa->start->next.root;
auto pn = dfa->start->price.root;
while (nn != nullptr) {
start->next.add(nn->data);
start->price.add(pn->data);
nn = nn->next;
pn = pn->next;
}
resumeEnd(start, dfa->end);
end = dfa->end;
}
visitable = !visitable;
}
void DFA::resumeEnd(state* s, state* newEnd)
{
if (!s) return;
for (auto n = s->next.root; n != nullptr; n = n->next) {
if (n->data == end) {
n->data = newEnd;
}
if (n->data != nullptr&&n->data->visitable == visitable) {
n->data->visitable = !visitable;
resumeEnd(n->data, newEnd);
}
}
}
理解这两个类的功能之后，我们正式开始构造DFA。
首先，我们需要先从文本中读入正则表达式。实现很容易，可以跳过。
void readExpression(const string filename) {
ifstream fin;
fin.open(filename);
if (fin.fail()) {
cout << "文件打开失败！" << endl;
system("pause");
exit(1);
}
string expression = "";
while (!fin.fail()) {
char ch = char(fin.get());
if (ch == ‘;‘) {
elis.add(expression);
expression = "";
continue;
}
expression = expression + ch;
}
fin.close();
}
以上代码中，elis是LEX程序的一个成员，它是一个链表，用于保存那些已经被读入的正则表达式。
接下来，我们就需要对表达式进行字符串解析了，哪些字符串是可以构造DFA的符号，哪些字符串是操作符。此时需要特别注意，括号及括号里面的内容应当被当做一个可构造DFA的符号来处理。需要括号里面内容的DFA时再来进行构造。
比如正则表达式：(letter|_)-((letter|_|digit)*);
在最开始处理这个表达式时，可以这样处理
令A1=letter|_ ,A2=(letter|_|digit)*
那么，我们构造的DFA将是
DFA=A1的DFA - A2的DFA，表达式也变成了(A1)-(A2)
可构造DFA的符号序列是：<A1,A2>
操作符序列是：<->
但是现在A1的DFA和A2的DFA我们不知道啊，我们实际上也不能直接根据一串表达式构造DFA，所以我们需要先去一步步构造A1和A2的DFA。
而A1的表达式是letter|_。
可构造DFA的符号序列是：<letter,_>
操作符序列是：<|>
所以我们可以先构造一个letter的DFA和一个-的DFA，然后再按照操作符序列将两者进行合并。可以这样写代码：
auto d1=new DFA(“letter”);
Auto d2=new DFA(“-”);
d1->addDFA(d2,’|’);
构造完A1的DFA之后，再去构造A2的DFA即可。做到这里的小伙伴很容易发现这里面是存在递归关系，所以这个构造DFA的函数应该采用递归的形式来编写。
DFA* createDFA(const string expression) {
//该链表用于保存表达式中各个符号生成DFA
DragonList<DFA*>* dlis = new DragonList<DFA*>();
//该链表用于保存表达式中的符号序列
DragonList<string>* slis = extractSymbol(expression);
//该链表用于保存表达式中的操作符序列
DragonList<char>* olis = extractOperator(expression);
//遍历符号链表
for (auto s = slis->root; s != nullptr; s = s->next) {
string str = s->data;
//如果某个符号里面带有括号，则需要递归的先行构造这个符号的子DFA
if (str[0] == ‘(‘) {
//剥离括号
str = str.substr(1,str.length()-2);
//递归调用createDFA函数，获取DFA
auto d = createDFA(str);
//将获取的DFA加入到DFA序列中
dlis->add(d);
continue;
}
//程序到这里说明当前符号是不带括号的，是可以直接构造DFA的符号
//查询已知的可构造符号列表，并构造DFA
for (int i = 0; i < symLen; i++) {
if (str == symbol[i]) {
auto d = new DFA(symbol[i]);
dlis->add(d);
}
}
}
//将DFA序列按照操作符序列进行合并，然后返回合并后的DFA
return mergeDFA(dlis, olis);
}
//将一个DFA序列按照一个操作符序列进行合并，得到一个DFA
DFA* mergeDFA(DragonList<DFA*>* dlis, DragonList<char>* olis)
{
//获取DFA序列中的第一个DFA作为初始DFA
DFA* d = dlis->root->data;
//获取DFA序列中的第一个DFA，用于遍历
auto dn = dlis->root;
//遍历操作符序列，进行合并
for (auto op = olis->root; op != nullptr; op = op->next) {
//如果操作符不是单目操作符，则需要使dn指向下一个DFA
if (op->data != ‘*‘) dn = dn->next;
if (dn == nullptr) break;
d->addDFA(dn->data, op->data);
}
return d;
}
至此，我们就能根据文本中的正则表达式来构建DFA了。