以下是文法First集和Follow集求解的算法代码示例（基于LL(1)文法）：
```
c++
#include <iostream>
#include <vector>
#include <un
ordered_
map>
#include <un
ordered_
set>
using namespace std;
// 定义文法符号类型
enum SymbolType {
TERMINAL,
NON_TERMINAL
};
// 定义文法符号
结构体
struct Symbol {
string name; // 符号名称
SymbolType type; // 符号类型
};
// 定义产生式
结构体
struct Production {
Symbol left; // 左部符号
vector<Symbol> right; // 右部符号序列
};
// 定义文法
结构体
struct Grammar {
vector<Production> productions; // 产生式序列
Symbol start; // 文法起始符号
};
// 计算文法符号的First集
un
ordered_
set<Symbol> computeFirst(const Symbol& symbol, const Grammar& grammar, un
ordered_
map<string, un
ordered_
set<Symbol>>& first
Map) {
un
ordered_
set<Symbol> first
Set;
// 如果该符号为终结符，则其First集只包含该符号本身
if (symbol.type == TERMINAL) {
first
Set.insert(symbol);
}
// 如果该符号为非终结符
else if (symbol.type == NON_TERMINAL) {
// 如果该符号的First集已经计算过，则直接返回缓存结果
if (first
Map.count(symbol.name)) {
return first
Map[symbol.name];
}
// 遍历该符号对应的所有产生式
for (const auto& production : grammar.productions) {
// 如果该产生式的左部符号与该符号相同，则计算该产生式右部符号序列的First集
if (production.left.name == symbol.name) {
for (const auto& rightSymbol : production.right) {
// 计算该符号的右部符号的First集
auto rightFirst
Set = computeFirst(rightSymbol, grammar, first
Map);
// 将该符号的右部符号的First集并入该符号的First集
first
Set.insert(rightFirst
Set.begin(), rightFirst
Set.end());
// 如果该符号的右部符号的First集不包含空串，则退出循环
if (!rightFirst
Set.count(Symbol{"", NON_TERMINAL})) {
break;
}
}
}
}
// 缓存该符号的First集
first
Map[symbol.name] = first
Set;
}
return first
Set;
}
// 计算文法符号的Follow集
un
ordered_
set<Symbol> computeFollow(const Symbol& symbol, const Grammar& grammar, un
ordered_
map<string, un
ordered_
set<Symbol>>& first
Map, un
ordered_
map<string, un
ordered_
set<Symbol>>& follow
Map) {
un
ordered_
set<Symbol> follow
Set;
// 如果该符号为文法起始符号，则将$加入其Follow集
if (symbol.name == grammar.start.name) {
follow
Set.insert(Symbol{"$", TERMINAL});
}
// 遍历所有产生式
for (const auto& production : grammar.productions) {
// 遍历该产生式右部符号序列，查找该符号的Follow集
for (auto it = production.right.begin(); it != production.right.end(); it++) {
// 如果当前符号与目标符号相同
if (it->name == symbol.name) {
// 如果目标符号不是该产生式的最后一个符号，则将其后继符号的First集并入其Follow集
if (next(it) != production.right.end()) {
auto nextSymbol = *next(it);
auto nextFirst
Set = computeFirst(nextSymbol, grammar, first
Map);
follow
Set.insert(nextFirst
Set.begin(), nextFirst
Set.end());
// 如果后继符号的First集包含空串，则将该产生式的左部符号的Follow集加入其Follow集
if (nextFirst
Set.count(Symbol{"", NON_TERMINAL})) {
auto leftFollow
Set = computeFollow(production.left, grammar, first
Map, follow
Map);
follow
Set.insert(leftFollow
Set.begin(), leftFollow
Set.end());
}
}
// 如果目标符号是该产生式的最后一个符号，则将该产生式的左部符号的Follow集加入其Follow集
else {
auto leftFollow
Set = computeFollow(production.left, grammar, first
Map, follow
Map);
follow
Set.insert(leftFollow
Set.begin(), leftFollow
Set.end());
}
}
}
}
// 缓存该符号的Follow集
follow
Map[symbol.name] = follow
Set;
return follow
Set;
}
int main() {
// 定义文法
Grammar grammar{
{
{"S", {Symbol{"a", TERMINAL}, Symbol{"B", NON_TERMINAL}}},
{"B", {Symbol{"S", NON_TERMINAL}, Symbol{"c", TERMINAL}}},
{"B", {Symbol{"d", TERMINAL}}}
},
Symbol{"S", NON_TERMINAL}
};
// 计算文法符号的First集
un
ordered_
map<string, un
ordered_
set<Symbol>> first
Map;
for (const auto& production : grammar.productions) {
for (const auto& symbol : production.right) {
computeFirst(symbol, grammar, first
Map);
}
}
// 输出文法符号的First集
for (const auto& [name, first
Set] : first
Map) {
cout << "First(" << name << ") = { ";
for (const auto& symbol : first
Set) {
cout << symbol.name << " ";
}
cout << "}" << endl;
}
// 计算文法符号的Follow集
un
ordered_
map<string, un
ordered_
set<Symbol>> follow
Map;
for (const auto& production : grammar.productions) {
computeFollow(production.left, grammar, first
Map, follow
Map);
}
// 输出文法符号的Follow集
for (const auto& [name, follow
Set] : follow
Map) {
cout << "Follow(" << name << ") = { ";
for (const auto& symbol : follow
Set) {
cout << symbol.name << " ";
}
cout << "}" << endl;
}
return 0;
}
```
1876
非常没帮助
没帮助
一般
有帮助
非常有帮助
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
