实验一：RegExp转NFA

已于 2024-01-30 08:59:26 修改
阅读量925 收藏 23
点赞数 30
分类专栏： 编译原理实践 hdu 文章标签： C++
于 2024-01-30 08:58:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wawa_is_studying/article/details/135925006
版权

1.中缀表达式转后缀表达式

后缀表达式是什么？

https://blog.csdn.net/a8425/article/details/119253258

核心操作：

*属于操作数（数字/字母）直接写上
*操作符*``|``(``)``^与栈内元素对比
*如果当前操作符为)，则依次退出栈内元素写上，直到出栈符号为(
*如果当前的优先级小于等于栈顶元素，则退出栈内元素写上，直到栈顶元素的优先级小于该元素，并入栈
image.png

2.后缀表达式转NFA

//NFA结构体
struct NFA {
	set<int> Q;
	set<char> alpha;
	vector<int> sigma[250][250];
	int start;
	set<int> end;
}NFA_instance;

STL set的使用

https://c.biancheng.net/view/7196.html
https://c.biancheng.net/view/7192.html

核心操作：

*核心算法：
image.png
image.png
image.pngimage.pngimage.png
*stack_start栈保存开始状态
*stack_end栈保存结束状态
*status_new保存最新编号
*边的转换的表示采用vector stl而不是数组，因为一个状态可能对应多个输入

具体实现

#include <iostream>
#include <stack>
#include <string>
#include <set>
#include <fstream>
#include <algorithm>
#include <vector>
using namespace std;
bool isOperator(char str) {
	if (str >= 'A' && str <= 'Z')
		return true;
	if (str >= 'a' && str <= 'z')
		return true;
	if (str >= '0' && str <= '9')
		return true;
	return false;
}
int getPriority(char str) {
	if (str == '(' || str == ')')
		return 1;
	if (str == '|')
		return 2;
	if (str == '^')
		return 3;
	if (str == '*')
		return 4;
	return 5;
}
string mid2after(string& mid_str) {
	char after_str[255] = { ' ' };
	int index = 0;
	stack<char> char_st;
	for (int i = 0; i < mid_str.length(); i++) {
		//mid2after 入栈操作
		if (isOperator(mid_str[i])) {
			after_str[index++] = mid_str[i];
		}
		else {
			//栈空
			if (char_st.empty())
			{
				char_st.push(mid_str[i]);
			}
			else {
				//栈不为空
				//当前为(
				if (mid_str[i] == '(')
				{
					char_st.push(mid_str[i]);
				}
				else {
					//栈不为空
					//当前为)
					//退栈直到(退出
					char top = char_st.top();
					if (mid_str[i] == ')') {
						while (top != '(') {
							after_str[index++] = top;
							char_st.pop();
							top = char_st.top();
						}
						char_st.pop();
					}
					else {
						//栈不为空
						//当前符号优先级小于等于栈顶优先级元素
						//退栈直到当前符号优先级大于栈顶元素
						//且防止空栈的情况
						if (getPriority(mid_str[i]) <= getPriority(top)) {
							while (getPriority(mid_str[i]) <= getPriority(top)) {
								after_str[index++] = top;
								char_st.pop();
								if (char_st.empty()) {
									break;
								}
								top = char_st.top();
							}
							char_st.push(mid_str[i]);
						}
						else {
							char_st.push(mid_str[i]);
						}
					}
				}
			}
		}
		//判断是否添加连接符^
		if (i < mid_str.length() - 1) {
			if ((isOperator(mid_str[i]) && isOperator(mid_str[i + 1])) ||
				(isOperator(mid_str[i]) && mid_str[i + 1] == '(') ||
				(mid_str[i] == ')' && mid_str[i + 1] == '(') ||
				(mid_str[i] == '*' && isOperator(mid_str[i + 1])) ||
				(mid_str[i] == '*' && mid_str[i + 1] == '(') ||
				(mid_str[i] == ')' && isOperator(mid_str[i + 1]))
				)
			{
				if (char_st.empty()) {
					char_st.push('^');
				}
				else {
					if (getPriority('^') <= getPriority(char_st.top())) {
						char top = char_st.top();
						while (getPriority('^') <= getPriority(top)) {
							after_str[index++] = top;
							char_st.pop();
							if (char_st.empty()) {
								break;
							}
							top = char_st.top();
						}
						char_st.push('^');
					}
					else {
						char_st.push('^');
					}
				}
			}
		}
	}
	//pop栈内剩余元素
	while (!char_st.empty()) {
		after_str[index++] = char_st.top();
		char_st.pop();
	}
	after_str[index] = '\0';
	string temp(after_str);
	return temp;
}

//NFA结构体
struct NFA {
	set<int> Q;
	set<char> alpha;
	vector<int> sigma[250][250];
	int start;
	set<int> end;
}NFA_instance;

//保存子图的开始状态和结束状态
stack<int> status_start;
stack<int> status_end;

//后缀表达式转NFA
void afer_exp2NFA(string after_exp) {
	//status_new标记当前最新状态编号
	int status_new = 0;
	for (int i = 0; i < after_exp.length(); i++) {
		if (isOperator(after_exp[i])) {
			NFA_instance.alpha.insert(after_exp[i]);
			NFA_instance.Q.insert(status_new);
			status_start.push(status_new);
			status_new++;
			NFA_instance.Q.insert(status_new);
			status_end.push(status_new);
			NFA_instance.sigma[status_start.top()][after_exp[i]].push_back(status_end.top());
			status_new++;
		}
		else {
			if (after_exp[i] == '*') {
				int pre = status_start.top();
				int nxt = status_end.top();
				int pre1 = status_new;
				status_new++;
				int nxt1 = status_new;
				NFA_instance.Q.insert(pre1);
				NFA_instance.Q.insert(nxt1);
				NFA_instance.sigma[nxt]['$'].push_back(pre);
				NFA_instance.sigma[nxt]['$'].push_back(nxt1);
				NFA_instance.sigma[pre1]['$'].push_back(pre);
				NFA_instance.sigma[pre1]['$'].push_back(nxt1);
				status_start.pop();
				status_end.pop();
				status_start.push(pre1);
				status_end.push(nxt1);
				status_new++;
			}
			else {
				if (after_exp[i] == '^') {
					int pre2 = status_start.top();
					int nxt2 = status_end.top();
					status_start.pop();
					status_end.pop();
					int pre1 = status_start.top();
					int nxt1 = status_end.top();
					status_start.pop();
					status_end.pop();
					NFA_instance.sigma[nxt1]['$'].push_back(pre2);
					status_start.push(pre1);
					status_end.push(nxt2);
				}
				else {
					if (after_exp[i] == '|') {
						int pre2 = status_start.top();
						int nxt2 = status_end.top();
						status_start.pop();
						status_end.pop();
						int pre1 = status_start.top();
						int nxt1 = status_end.top();
						status_start.pop();
						status_end.pop();
						int pre3 = status_new;
						status_new++;
						int nxt3 = status_new;
						NFA_instance.Q.insert(pre3);
						NFA_instance.Q.insert(nxt3);
						NFA_instance.sigma[pre3]['$'].push_back(pre2);
						NFA_instance.sigma[pre3]['$'].push_back(pre1);
						NFA_instance.sigma[nxt2]['$'].push_back(nxt3);
						NFA_instance.sigma[nxt1]['$'].push_back(nxt3);
						status_start.push(pre3);
						status_end.push(nxt3);
						status_new++;
					}
				}
			}
		}
	}
	NFA_instance.start = status_start.top();
	NFA_instance.end.insert(status_end.top());
	NFA_instance.alpha.insert('$');
}

void printNFA(ofstream &outputFile) {
	outputFile << "graph NFA" << endl;
	for (auto q = NFA_instance.Q.begin(); q != NFA_instance.Q.end(); q++) {
		for (auto q1 = NFA_instance.alpha.begin(); q1 != NFA_instance.alpha.end(); q1++) {
			if (!NFA_instance.sigma[*q][*q1].empty()) {
				for (auto q2 = NFA_instance.sigma[*q][*q1].begin(); q2 != NFA_instance.sigma[*q][*q1].end(); q2++) {
					if (NFA_instance.start == *q) {
						outputFile << "(start)" << *q << " " << *q2 << " " << *q1 << endl;
					}
					else {
						if (NFA_instance.end.find(*q2) != NFA_instance.end.end()) {
							outputFile << *q << " " << *q2 << "(end) " << *q1 << endl;
						}
						else {
							outputFile << *q << " " << *q2 << " " << *q1 << endl;
						}
					}
				}
			}
		}
	}
}

//DFA结构体
struct DFA {
	set<int> Q;
	set<char> alpha;
	int sigma[25][250];
	int start;
	set<int> end;
}DFA_instance;

set<int> e_closure[25];
stack<int> bfs;
set<int> Dstates[25];
set<int> temp;
set<char> temp_c;

void NFA2DFA() {
	test 初始化NFA
	//for (int i = 0; i <= 9; i++) {
	//	NFA_instance.Q.insert(i);
	//}
	//NFA_instance.start = 0;
	//NFA_instance.end.insert(9);
	//NFA_instance.alpha.insert('$');
	//NFA_instance.alpha.insert('a');
	//NFA_instance.alpha.insert('b');
	//NFA_instance.sigma[0]['$'].push_back(1);
	//NFA_instance.sigma[0]['$'].push_back(7);
	//NFA_instance.sigma[1]['$'].push_back(2);
	//NFA_instance.sigma[1]['$'].push_back(4);
	//NFA_instance.sigma[2]['a'].push_back(3);
	//NFA_instance.sigma[3]['$'].push_back(6);
	//NFA_instance.sigma[4]['b'].push_back(5);
	//NFA_instance.sigma[5]['$'].push_back(6);
	//NFA_instance.sigma[6]['$'].push_back(1);
	//NFA_instance.sigma[6]['$'].push_back(7);
	//NFA_instance.sigma[7]['a'].push_back(8);
	//NFA_instance.sigma[8]['b'].push_back(9);

	//DFA和NFA的alpha字符集合并
	set_union(NFA_instance.alpha.begin(), NFA_instance.alpha.end(), temp_c.begin(), temp_c.end(), inserter(DFA_instance.alpha,DFA_instance.alpha.begin()));
	//DFA中无$边
	DFA_instance.alpha.erase('$');
	//求出各状态的e-closure
	for (auto q = NFA_instance.Q.begin(); q != NFA_instance.Q.end(); q++) {
		if (!NFA_instance.sigma[*q]['$'].empty()) {
			bfs.push(*q);
			while (!bfs.empty()) {
				int top = bfs.top();
				bfs.pop();
				e_closure[*q].insert(top);
				if (!NFA_instance.sigma[top]['$'].empty()) {
					for (auto q1 = NFA_instance.sigma[top]['$'].begin(); q1 != NFA_instance.sigma[top]['$'].end(); q1++) {
						bfs.push(*q1);
					}
				}
			}
		}
		else {
			e_closure[*q].insert(*q);
		}
	}
	//验证e-closure输出的正确性
	//for (auto q = NFA_instance.Q.begin(); q != NFA_instance.Q.end(); q++) {
	//	cout << "e-closure of " << *q << " : ";
	//	for (auto q1 = e_closure[*q].begin(); q1 != e_closure[*q].end(); q1++) {
	//		cout << *q1 << " ";
	//	}
	//	cout << endl;
	//}

	//求出第一个状态子集
	//Dstates[0]对应NFA_instance.start的闭包
	set_union(e_closure[NFA_instance.start].begin(), e_closure[NFA_instance.start].end(), temp.begin(), temp.end(), inserter(Dstates[0], Dstates[0].begin()));
	int j = 0, p = 0;
	//转换矩阵DFA_instance.sigma
	for (int i = 0; i < 25; i++) {
		for (int j = 0; j < 250; j++) {
			DFA_instance.sigma[i][j] = -1;
		}
	}
	//j表示当前处理的状态子集
	//p表示总状态子集数
	while (j <= p) {
		
		for (auto alpha = DFA_instance.alpha.begin(); alpha != DFA_instance.alpha.end(); alpha++) {
			set<int> temp_Dstate;
			set<int> e_temp_Dstate;
			//得到Dstates[j]有符号边的转换集合temp_Dstate
			//Dstates[j]面对每一种符号输入的处理
			for (auto q = Dstates[j].begin(); q != Dstates[j].end(); q++) {
				if (!NFA_instance.sigma[*q][*alpha].empty()) {
					for (auto q1 = NFA_instance.sigma[*q][*alpha].begin(); q1 != NFA_instance.sigma[*q][*alpha].end(); q1++) {
						temp_Dstate.insert(*q1);
					}
				}
			}

			//test 测试符号闭包
			//发现未清空temp_Dstate和e_temp_Dstate导致错误
			//cout << "closure of " << j << " with alpha " << *alpha << " : ";
			//for (auto q = temp_Dstate.begin(); q != temp_Dstate.end(); q++) {
			//	cout << *q << " ";
			//}
			//cout << endl;

			//求出temp_Dstate转换集合的e闭包e_temp_Dstate
			//转换集合temp_Dstate为空，一定没有产生新状态，产生的e_temp_Dstate是原本的Dstate[j]
			//转换集合temp_Dstate不为空，可能产生新状态，需要将产生的新状态与之前的Dstates中记录的对比
			if (!temp_Dstate.empty()) {
				for (auto state = temp_Dstate.begin(); state != temp_Dstate.end(); state++) {
					int index = *state;
					set_union(e_closure[index].begin(), e_closure[index].end(), temp.begin(), temp.end(), inserter(e_temp_Dstate, e_temp_Dstate.begin()));
				}
				//flag 1表示产生新状态
				//	   0	未产生新状态
				int flag = 1;
				int index = -1;
				//index用于未产生新状态时，标记当前符号输入下产生的状态对应哪个旧状态
				for (int i = 0; i <= p; i++) {
					set<int> diff;
					set_difference(e_temp_Dstate.begin(), e_temp_Dstate.end(), Dstates[i].begin(), Dstates[i].end(), inserter(diff, diff.begin()));
					if (diff.empty()) {
						flag = 0;
						index = i;
						break;
					}
				}
				if (flag == 1) {
					p++;
					set_union(e_temp_Dstate.begin(), e_temp_Dstate.end(), temp.begin(), temp.end(), inserter(Dstates[p], Dstates[p].begin()));
					DFA_instance.sigma[j][*alpha] = p;
				}
				else {
					DFA_instance.sigma[j][*alpha] = index;
				}
			}
			else {
				DFA_instance.sigma[j][*alpha] = -1;
			}
		}

		//cout << "closure of " << j << " : ";
		//for (auto q = Dstates[j].begin(); q != Dstates[j].end(); q++) {
		//	cout << *q << " ";
		//}
		//cout << endl;

		j++;
	}
	for (int i = 0; i <= p; i++) {
		DFA_instance.Q.insert(i);
	}
	DFA_instance.start = 0;
	for (auto q = NFA_instance.end.begin(); q != NFA_instance.end.end(); q++) {
		for (int i = 0; i <= p; i++) {
			if (Dstates[i].find(*q) != Dstates[i].end()) {
				DFA_instance.end.insert(i);
			}
		}
	}
}

void printDFA(ofstream& outputFile) {
	outputFile << "graph DFA" << endl;
	for (auto q = DFA_instance.Q.begin(); q != DFA_instance.Q.end(); q++) {
		for (auto q1 = DFA_instance.alpha.begin(); q1 != DFA_instance.alpha.end(); q1++) {
			if (DFA_instance.sigma[*q][*q1] != -1) {
				int q2 = DFA_instance.sigma[*q][*q1];
				if (DFA_instance.start == *q) {
					outputFile << "(start)" << *q << " " << q2 << " " << *q1 << endl;
				}
				else {
					if (DFA_instance.end.find(q2) != DFA_instance.end.end()) {
						outputFile << *q << " " << q2  << "(end) " << *q1 << endl;
					}
					else {
						outputFile << *q << " " << q2 << " " << *q1 << endl;
					}
				}
			}
		}
	}
}

void clear() {
	//重新配置全局变量
	NFA_instance.Q.clear();
	NFA_instance.alpha.clear();
	NFA_instance.end.clear();
	NFA_instance.start = -1;
	for (int i = 0; i < 250; i++) {
		for (int j = 0; j < 250; j++) {
			NFA_instance.sigma[i][j].clear();
		}
	}
	while (!status_start.empty()) {
		status_start.pop();
	}
	while (!status_end.empty()) {
		status_end.pop();
	}
	DFA_instance.Q.clear();
	DFA_instance.alpha.clear();
	for (int i = 0; i < 25; i++) {
		for (int j = 0; j < 250; j++) {
			DFA_instance.sigma[i][j] = -1;
		}
	}
	DFA_instance.start = -1;
	DFA_instance.end.clear();
	for (int i = 0; i < 25; i++) {
		e_closure[i].clear();
		Dstates[i].clear();
	}
	while (!bfs.empty()) {
		bfs.pop();
	}
	temp.clear();
	temp_c.clear();
}

int main() {
	string file_path = "./reg.txt";
	ifstream file(file_path);
	string arr[100];
	int count = 0;
	while (getline(file, arr[count]) && count < 100) {
		if (arr[count].empty()) {
			break;
		}
		count++;
	}
	file.close();
	ofstream outputFile("./output.txt");
	for (int i = 0; i < count; i++) {
		string mid_exp = arr[i];
		clear();
		outputFile << "input mid_exp is : " << mid_exp << endl;
		string after_exp = mid2after(mid_exp);
		outputFile << "after_exp is : ";
		outputFile << after_exp << endl;
		afer_exp2NFA(after_exp);
		printNFA(outputFile);
		NFA2DFA();
		printDFA(outputFile);
		outputFile << endl;
	}
	return 0;
}
哇哇哇哇池
关注
  • 30
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
简单后缀表达式转nfa 正则匹配 Python
Nonikka的小方舟
04-19 2198
简单学习了状态机的知识 先记录下来 global stack class State: #counter = 0 def __init__(self,c,out = None,out1 = None): self.c = c self.out = out self.out1 = out1 self.lastlis
编译原理：正则表达式/正规式转NFA（原理+完整代码+可视化实现）
Toby的博客
12-04 4625
本文为做编译原理实践时候有感而发写的文章，主要内容是将正规表达式转换为NFA，欢迎学习参考！
正规式转换为NFA代码实现
Carmelo_7的博客
10-11 6062
问题引入 正规式是一种编译原理课程中经常提到的描述文法的语法规则，与正则表达式有相同之处，但并不是同一个概念。有效的正规式的字母表∑ = { a − z , A − Z } 。 所有的正规式中的符号以及对应的规则如下： ‘*’：表示闭包； ‘|’：表示联合（或）——在有的版本中也用’+'来表示； ‘.’：表示连接（与）； NFA（non-deterministic finite automaton with ε-move,ε-NFA）带空移动的非确定的有穷状态自动机 从正规式到NFA的转换是编译原理课程中经
正规表达式转NFA
10-24
编译原理中的正规表达式转NFA，比较完美，不过没有判断点连接符号和正闭包。
正则表达式转NFA
07-09
课程设计 正规式构造nfa.这是编译原理的一个实验, 是把一个正则表达式转化为不确定有穷自动机NFA的算法程序,朋兴趣的朋友可以下载来看看哦。
regexhelper:RegExp帮助程序库
05-29
regexhelper RegExp帮助程序库-在Node.js和浏览器中均可使用要将克隆安装到桌面，或下载并解压缩到库或脚本目录。 节点使用情况： var RegexHelper = require('regexhelper.js'),在浏览器中： [removed][removed]...
编译原理：正规式转NFA（有穷自动机）
最新发布
06-08
在编译原理中，正规式（Regular Expression）到非确定有限状态自动机（Non-Deterministic Finite Automaton，简称NFA）的转换是一项基础且重要的概念。正规式是一种用于描述字符串集的简洁形式，常用于正则表达式，...
正则表达式转NFA实现
10-21
正则表达式通常简称为“regex”或“regexp”，可以表示一系列简单的到复杂的字符模式。 正则表达式的转换通常涉及到将其转化为一种计算模型，以便更方便地进行匹配操作。其中，非确定性有限自动机（NFA，Non-...
BetterRegExp:RegExp 上的实用程序包装器
07-13
RegExp 上的实用程序包装器 节点版本 >= 0.4 用法 构造函数 BetterRegExp = require " BetterRegExp " # Create from RegExp pat = BetterRegExp / ^ \s * \d + \s * $ / gi pat = BetterRegExp / ^ \s * \d + \s *...
RegExp.tag:RegExp.escape 提议的基于模板字符串的替代方案
05-30
在其他语言中，有一种方法可以通过类似于提议的工具来转义文字： Perl：quotemeta(str) - 参见 PHP：preg_quote(str) - 请参阅 Python：re.escape(str) - 请参阅 Ruby：Regexp.escape(str) - 请参阅 Java：Patt
词法分析程序之正规式转换成NFA
热门推荐
程序猿一帆
10-27 2万+
想知道正则表达式背后的原理吗？来瞧瞧吧，这里都有。
C++实现正则表达式转最小化DFA过程详解
李阿祥的学习笔记
11-07 1万+
目前学校正在开编译原理这门课。为了加深对正则表达式转最小化DFA的理解，利用c++编写了这个程序。现在把我的程序及实现的方法分享出来，希望能对大家的学习有所帮助。 本文主要从以下几个方面进行讲解正则表达式操作数运算符算法流程1.正则表达式的预处理2.中缀表达式转后缀表达式3.后缀表达式创建NFA4.NFA转化为DFA5.DFA的最小化合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片...
正规式->最小化DFA说明
flyear_cn
03-22 6350
今天早上去图书馆，去看编译原理，想把这部分搞清楚，看着龙书+国产的某一本不知什么的习题与解析，猜过程。。猜原理。。终于是看懂了。。 整体的步骤是三步： 一，先把正规式转换为NFA（非确定有穷自动机）, 二，在把NFA通过“子集构造法”转化为DFA， 三，在把DFA通过“分割法”进行最小化。 　　　一步很简单，就是反复运用下图的规则，图1 　　这样就能转换到NFA了。 给出
正规表达式 转 NFA C++
weixin_30825199的博客
12-21 2026
　　今天来为大家分享一个编译原理中用正规表达式转NFA的小程序 正规表达式就是类似正则一样的式子，例如：（a|b）*abb，最后应该转化为： 大致的处理流程为： 例子中的表达式：（a|b）*abb，|和*都是运算法则，而且容易识别，但是处理abb就不是你那么方便了，所以我们在abb中间加上+号，就可以像|*那样识别了，所以处理后为(a|b)*a+b+b 我们识别...
常规表达式转换为后缀表达式
iamzzg1988的专栏
12-21 984
该类主要用于转换常规自定义表达式为后缀表达式，方便解析。目前仅支持‘同类运行符+括号’的表达式，以后如果有同类需求只需要新添规则即可
正规表达式转NFA(C++)
YiShi's Blog
10-02 1万+
分析 表达式里包含五种符号：左括号，右括号，连接符，选择符，闭包符。 连接符因为优先级最高，可以将其过滤掉，不予考虑。 闭包符* 首先来说闭包，无非两种情况： X* 或者 (…..)* 两者都可以看做是从一个起始状态，经过诸多输入到达一个终止状态。如 1– X –>2 和 1– (……) –> 2。 那么闭包符可以看做是以下操作：
第三章——正规式与有限自动机（NFA M与正规式R的相互转化）
qq_40240576的博客
10-08 8701
一. NFA M ——&amp;gt; 正规式R 步骤： （1）用x , y代表开始和结束状态加入原来状态转换图 （2）消除x , y之间的状态直至只剩x , y为止，没消除一个状态，重新连接两个状态的弧用正规式表示。 消除规则： 例题： ...
QVariant::RegExp 不存在
06-07
如果您在使用 QVariant 时遇到了 "QVariant::RegExp does not exist" 错误，这可能是因为您使用的 Qt 版本太低，不支持 QVariant::RegExp 类型。 QVariant::RegExp 类型是在 Qt 5.0 中引入的，用于存储正则表达式。如果您使用的是 Qt 5.0 或更高版本，则可以使用 QVariant::RegExp 类型。 如果您使用的是 Qt 4.x 版本，则不支持 QVariant::RegExp 类型。在这种情况下，您可以考虑使用 QVariant::String 类型来存储正则表达式，然后在需要使用正则表达式的地方将 QVariant 转换为 QRegExp 类型。 例如，假设您需要将一个正则表达式存储在 QVariant 对象中，您可以使用以下代码： ```cpp QVariant var; QRegExp regex("hello,\\s+world", Qt::CaseInsensitive); var.setValue(regex.pattern()); ``` 这样，QVariant 对象 var 中就存储了一个正则表达式，并且可以通过 QVariant::toString() 方法获取该正则表达式的字符串表示形式。 如果需要使用该正则表达式进行匹配，可以使用以下代码： ```cpp QVariant var; // 假设 var 中存储了正则表达式字符串 QRegExp regex(var.toString(), Qt::CaseInsensitive); bool match = regex.exactMatch("Hello, world!"); ``` 这样，就可以使用 QVariant 存储和使用正则表达式了。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值