接上一篇词法分析器第二部分

最新推荐文章于 2024-08-19 21:51:40 发布
最新推荐文章于 2024-08-19 21:51:40 发布
阅读量430 收藏
点赞数
文章标签： 正则表达式 delete ios string input class
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sangzixuetong/article/details/5656759
版权

//接上篇

// 定义DFA的构造类
class DFA
{
public:
 DFA();
 ~DFA();
 void GetRegExp();
 void InsertCatNode();
 void RegExpToPost();
 void GetEdgeNumber();
 void ThompsonConstruction();
 void SubsetConstruction();
 void FindMatchingPatternInFile();
private:
 char *exp;
 char *post;
 char *edge;
 int edgeNumber;
 int **DStates;
 int **Dtran;
 int *AcceptStates;
 int DStatesNumber;
 int DtranNumber;
 int NFAStatesNumber;
 int DFAStatesNumber;
 AdjacentTable *NFATable;
 TransitionTable *DFATable;
 int Precedence(char symbol);
 int CompArray(int *t1, int *t2);
 int MinimizeDFAStates(int **Dtran, int *AcceptStates, int DtranNumber, int edgeNumber);
 void RemoveFirstSymbol(char *buf, int &len);
};
// 构造函数
DFA::DFA()
{
 exp = new char[128];
 post = new char[128];
 edge = new char[128];
    edgeNumber = 0;
 NFAStatesNumber = 0;
 DFAStatesNumber = 0;
 DStatesNumber = 0;
 DtranNumber = 0;
 NFATable = new AdjacentTable();
}
// 析构函数
DFA::~DFA()
{
 delete [] exp;
 delete [] post;
 delete [] edge;
 delete [] AcceptStates;
 NFATable->Clear();
 DFATable->Clear();
}
// 获取输入
void DFA::GetRegExp()
{
 cout << "在下面输入正则表达式" << endl;
 cin >> exp;
 for (int i=0; exp[i]!='/0'; i++)
 {
  if (exp[i] == '~')
  {
   cout << "/n字符'~'已经被程序禁用！" << endl;
   getch();
   exit(1);
  }
 }
 cout << "/n------------------------" << endl;
}
// 加入cat-node作为连结点标志
void DFA::InsertCatNode()
{
 int i = 0, j, len = strlen(exp);
 while (exp[i+1] != '/0')
 {
  if (((exp[i] != '(' && exp[i] != '.' && exp[i] != '|') 
   || exp[i] == ')' 
   || exp[i] == '*')
   && (exp[i+1] != ')' && exp[i+1] != '.' && exp[i+1] != '|' && exp[i+1] != '*'))
  {
   for (j=len; j>i+1; j--)
   {
    exp[j] = exp[j-1];
   }
   exp[i+1] = '.';
   len++;
   exp[len] = '/0';
   i++;
  }
  i++;
 }
 cout << "/n第一步: 加入连结点/n"
   << exp << "/n"
   << "字符串长度: " << len 
   << "/n/n------------------------" << endl;
}
// 定义运算符的优先级
int DFA::Precedence(char symbol)
{
 int priority;
 switch (symbol)
 {
 case '|': priority = 1; break;
 case '.': priority = 2; break;
 case '*': priority = 3; break;
 default:  priority = 0; break;
 }
 return priority;
}
// 将正则式转为逆波兰式
void DFA::RegExpToPost()
{
 int i = 0, j = 0;
 char ch, cl;
 strcpy(post, "/0");
 LStack<char> *ls = new LStack<char>();
 ls->Clear();
 ls->Push('#');
 ch = exp[i];
 while (ch != '/0')
 {
  if (ch == '(')
  {
   ls->Push(ch);
   ch = exp[++i];
  }
  else if (ch == ')')
  {
   while (ls->GetTop() != '(')
   {
    post[j++] = ls->Pop();
   }
            ls->Pop();
   ch = exp[++i];
  }
  else if ((ch == '|') || (ch == '*') || (ch == '.'))
  {
      cl = ls->GetTop();
      while (Precedence(cl) >= Precedence(ch))
   {
       post[j++] = cl;
       ls->Pop();
       cl = ls->GetTop();
   }
   ls->Push(ch);
   ch = exp[++i];
  }
  else
  {
   post[j++] = ch;
   ch = exp[++i];
  }
 }
 ch = ls->Pop();
 while ((ch == '|') || (ch == '*') || (ch == '.'))
 {
  post[j++] = ch;
  ch = ls->Pop();
 }
 post[j] = '/0';
 ls->Clear();
 cout << "/n第二步: 转为后缀式/n"
   << post << "/n"
   << "字符串长度: " << strlen(post) 
   << "/n/n------------------------" << endl;
}
// 扫描逆波兰式中除运算符以外的字符的数目
void DFA::GetEdgeNumber()
{
 int i = 0, j;
 edgeNumber = 0;
 while (post[i] != '/0')
 {
  if (post[i] == '.' || post[i] == '|' || post[i] == '*')
  {
   i++;
   continue;
  }
  for (j=0; j<edgeNumber; j++)
  {
   if (post[i] == edge[j])
   {
    break;
   }
  }
  if (j == edgeNumber)
  {
   edge[edgeNumber] = post[i];
   edgeNumber++;
  }
  i++;
 }
 edge[edgeNumber] = '/0';
 cout << "/n第三步: 获取字符集/n";
 for (i=0; i<edgeNumber; i++)
 {
  cout << edge[i] << ' ';
 }
 cout << "/n字符个数: " << edgeNumber 
   << "/n/n------------------------" << endl;
}
// 用Thompson构造法构造NFA
void DFA::ThompsonConstruction()
{
 int i, j;
 char ch;
 int s1, s2;
 LStack<int> *states = new LStack<int>();
 states->Clear();
 if (strlen(post) < 1)
 {
  cout << "No Valid Regular Expression Found!" << endl;
  getch();
  exit(1);
 }
 NFATable->SetValue(0, 0);
 i = 1;
 j = 0;
 ch = post[j];
    while (ch != '/0')
 {
  if (ch == '.')
  {
   s2 = states->Pop();
   int temp1 = states->Pop();
   int temp2 = states->Pop();
   s1 = states->Pop();
   NFATable->InsertEdgeByValue(temp2, temp1, '~');
   states->Push(s1);
   states->Push(s2);
  }
  else if (ch == '|')
  {
   s2 = states->Pop();
   int temp1 = states->Pop();
   int temp2 = states->Pop();
   s1 = states->Pop();
   NFATable->InsertVertex(i);
   NFATable->InsertVertex(i+1);
   NFATable->InsertEdgeByValue(i, s1, '~');
   NFATable->InsertEdgeByValue(i, temp1, '~');
   NFATable->InsertEdgeByValue(temp2, i+1, '~');
   NFATable->InsertEdgeByValue(s2, i+1, '~');
   s1 = i;
   s2 = i+1;
   states->Push(s1);
   states->Push(s2);
   i += 2;
  }
  else if (ch == '*')
  {
   s2 = states->Pop();
   s1 = states->Pop();
   NFATable->InsertVertex(i);
   NFATable->InsertVertex(i+1);
   NFATable->InsertEdgeByValue(i, i+1, '~');
   NFATable->InsertEdgeByValue(s2, s1, '~');
   NFATable->InsertEdgeByValue(i, s1, '~');
   NFATable->InsertEdgeByValue(s2, i+1, '~');
   s1 = i;
   s2 = i+1;
   states->Push(s1);
   states->Push(s2);
   i += 2;
  }
  else
  {
   NFATable->InsertVertex(i);
   NFATable->InsertVertex(i+1);
   NFATable->InsertEdgeByValue(i, i+1, ch);
   s1 = i;
   s2 = i+1;
   states->Push(s1);
   states->Push(s2);
   i += 2;
  }
  j++;
  ch = post[j];
 }
 s2 = states->Pop();
 s1 = states->Pop();
 NFATable->InsertEdgeByValue(0, s1, '~');
 if (! states->IsEmpty())
 {
  cout << "Some error in your input string!" << endl;
  getch();
  exit(1);
 }
 NFAStatesNumber = s2 + 1;
}
// 比较两个一维数组是否含有完全相同的元素
int DFA::CompArray(int *t1, int *t2)
{
 int i = 0, j = 0, len1, len2;
 while (t1[i] != -1)
 {
  i++;
 }
 len1 = i;
 while (t2[j] != -1)
 {
  j++;
 }
 len2 = j;
 if (len1 != len2)
 {
  return 0;
 }
 for (i=0; i<len1; i++)
 {
  for (j=0; j<len2; j++)
  {
   if (t1[i] == t2[j])
   {
    break;
   }
  }
  if (j == len2)
  {
   return 0;
  }
 }
 return 1;
}
// 最小化Dtran表
int DFA::MinimizeDFAStates(int **Dtran, int *AcceptStates, int DtranNumber, int edgeNumber)
{
 int h, i, j, k, l;
 for (i=0; i<DtranNumber-1; i++)
 {
  for (j=i+1; j<DtranNumber; j++)
  {
   if (AcceptStates[i] == AcceptStates[j])
   {
    for (k=0; k<edgeNumber; k++)
    {
     if (Dtran[i][k] != Dtran[j][k])
     {
      break;
     }
    }
    if (k == edgeNumber)
    {
     for (l=j; l<DtranNumber-1; l++)
     {
      for (k=0; k<edgeNumber; k++)
      {
       Dtran[l][k] = Dtran[l+1][k];
      }
      AcceptStates[l] = AcceptStates[l+1];
     }
     for (l=0; l<DtranNumber-1; l++)
     {
      for (k=0; k<edgeNumber; k++)
      {
       if (Dtran[l][k] == j)
       {
        Dtran[l][k] = i;
       }
      }
     }
     for (h=j; h<DtranNumber; h++)
     {
      for (l=0; l<DtranNumber-1; l++)
      {
       for (k=0; k<edgeNumber; k++)
       {
        if (Dtran[l][k] == h+1)
        {
         Dtran[l][k] = h;
        }
       }
      }
     }
     DtranNumber--;
     j--;
    }
   }
  }
 }
 return DtranNumber;
}
// 用子集构造法构造DFA
void DFA::SubsetConstruction()
{
 int i, j, k;
 DStatesNumber = 0;
 DtranNumber = 0;
 // 输出NFA状态表
 cout << "/n第四步: 构造NFA/n/n";
    NFATable->OutputNFA();
 cout << "/n------------------------" << endl;
 // 初始化DStates和Dtran两个构造表及AcceptStates数组
 DStates = (int**)(new int*[NFAStatesNumber+1]);
 for (i=0; i<NFAStatesNumber+1; i++)
 {
  DStates[i] = new int[NFAStatesNumber+1];
 }
 Dtran = (int**)(new int*[NFAStatesNumber+1]);
 for (i=0; i<NFAStatesNumber+1; i++)
 {
  Dtran[i] = new int[edgeNumber+1];
 }
 for (i=0; i<NFAStatesNumber+1; i++)
 {
  for (j=0; j<edgeNumber+1; j++)
  {
   Dtran[i][j] = -1;
  }
 }
 AcceptStates = new int[NFAStatesNumber+1];
 for (i=0; i<NFAStatesNumber+1; i++)
 {
  AcceptStates[i] = 0;
 }
 // 调用闭包函数和移动函数构造DStates和Dtran两个表及AcceptStates数组
    int *T = new int[NFAStatesNumber+1];
 int *temp = new int[NFAStatesNumber+1];
 T[0] = 0;
 T[1] = -1;
 T = NFATable->Closure(T);
 DStates[DStatesNumber] = T;
 DStatesNumber++;
 k = 0;
 while (k < DStatesNumber)
 {
  for (i=0; edge[i]!='/0'; i++)
  {
   temp = NFATable->Closure(NFATable->Move(T, edge[i]));
   if (temp[0] != -1)
   {
    for (j=0; j<DStatesNumber; j++)
    {
     if (CompArray(temp, DStates[j]) == 1)
     {
      Dtran[k][i] = j;
      break;
     }
    }
    if (j == DStatesNumber)
    {
     DStates[DStatesNumber] = temp;
     Dtran[k][i] = DStatesNumber;
     DStatesNumber++;
    }
   }
  }
  k++;
  T = DStates[k];
 }
 DtranNumber = k;
 for (i=0; i<DStatesNumber; i++)
 {
  for (j=0; DStates[i][j]!= -1; j++)
  {
   if (DStates[i][j] == NFAStatesNumber - 1)
   {
    AcceptStates[i] = 1;
    break;
   }
  }
 }
 // 输出DStates表项
 cout << "/n第五步: 构造DStates表/n/n";
 for (i=0; i<DStatesNumber; i++)
 {
  cout << "项目" << i <<":  ";
  j = 0;
  while (DStates[i][j] != -1)
  {
   cout << DStates[i][j] << " ";
   j++;
  }
  cout << endl;
 }
 cout << "/n------------------------" << endl;
 // 输出Dtran表项
 cout << "/n第六步: 构造Dtran表/n/n状态 ";
 for (j=0; j<edgeNumber; j++)
 {
  cout << "    " << edge[j];
 }
 cout << "    是否接收" << endl;
 for (i=0; i<DtranNumber; i++)
 {
  if (i < 10)  cout << "   " << i << " ";
  else if (i < 100)  cout << "  " << i << " ";
  else if (i < 1000)  cout << " " << i << " ";
  else  cout << i << " ";
  for (j=0; j<edgeNumber; j++)
  {
   if (Dtran[i][j] < 0)  cout << "     ";
   else if (Dtran[i][j] < 10)  cout << "    " << Dtran[i][j];
   else if (Dtran[i][j] < 100)  cout << "   " << Dtran[i][j];
   else if (Dtran[i][j] < 1000)  cout << "  " << Dtran[i][j];
   else  cout << " " << Dtran[i][j];
  }
  if (AcceptStates[i] == 1)
  {
   cout << "    Acc";
  }
  cout << endl;
 }
 cout << "/n------------------------" << endl;
 // 反复检测Dtran表中是否能化简，能则继续化简
 int DtranNumberAfterMinimization = MinimizeDFAStates(Dtran, AcceptStates, DtranNumber, edgeNumber);
 while (DtranNumberAfterMinimization != DtranNumber)
 {
  DtranNumber = DtranNumberAfterMinimization;
  DtranNumberAfterMinimization = MinimizeDFAStates(Dtran, AcceptStates, DtranNumber, edgeNumber);
 }
 // 将Dtran表的内容拷贝到DFA表
 DFATable = new TransitionTable(DtranNumber, edgeNumber);
 for (i=0; i<DtranNumber; i++)
 {
  for (j=0; j<edgeNumber; j++)
  {
   DFATable->SetValue(i, j, Dtran[i][j]);
  }
 }
 // 输出DFA状态表
 cout << "/n第七步: 构造最小DFA/n/n状态 ";
 for (j=0; j<edgeNumber; j++)
 {
  cout << "    " << edge[j];
 }
 cout << "    是否接收" << endl;
 for (i=0; i<DtranNumber; i++)
 {
  if (i < 10)  cout << "   " << i << " ";
  else if (i < 100)  cout << "  " << i << " ";
  else if (i < 1000)  cout << " " << i << " ";
  else  cout << i << " ";
  for (j=0; j<edgeNumber; j++)
  {
   if (DFATable->GetValue(i, j) < 0)  cout << "     ";
   else if (DFATable->GetValue(i, j) < 10)  cout << "    " << DFATable->GetValue(i, j);
   else if (DFATable->GetValue(i, j) < 100)  cout << "   " << DFATable->GetValue(i, j);
   else if (DFATable->GetValue(i, j) < 1000)  cout << "  " << DFATable->GetValue(i, j);
   else  cout << " " << DFATable->GetValue(i, j);
  }
  if (AcceptStates[i] == 1)
  {
   cout << "    Acc";
  }
  cout << endl;
 }
 cout << "/n------------------------" << endl;
 // 析构DStates和Dtran表以及AcceptStates数组
 for (i=0; i<NFAStatesNumber+1; i++)
 {
  delete [] DStates[i];
  delete [] Dtran[i];
 }
 delete [] DStates;
 delete [] Dtran;
}
// 从字符串中删除第一个字符
void DFA::RemoveFirstSymbol(char *buf, int &len)
{
 for (int i=0; i<len-1; i++)
 {
  buf[i] = buf[i+1];
 }
 len--;
 buf[len] = '/0';
}
// 从ASCII文件中找出所有的匹配式
void DFA::FindMatchingPatternInFile()
{
 cout << "/n第八步: 查找匹配字符串/n/n";
 // 打开一个只读文件和一个写文件
 char filePath[128];
 cout << "请输入要打开的文件" << endl;
 cin >> filePath;
 fstream infile;
 infile.open(filePath, ios::in|ios::nocreate);
 if (! infile)
 {
  cout << "/n打开文件" << filePath << "失败！" << endl;
  getch();
  exit(1);
 }
 cout << "请输入保存记录的文件" << endl;
 cin >> filePath;
 fstream outfile;
 outfile.open(filePath, ios::out|ios::trunc);
 if (! outfile)
 {
  cout << "/n建立文件" << filePath << "失败！" << endl;
  getch();
  exit(1);
 }
 // 开始验证正则表达式的匹配串
 int ln = 1, col = 0, bufHead = 0;
 int state = 0;
 int count = 0;
 char buf[256];
 int curr = 0;
 int len = 0;
 char ch;
 while (infile.get(ch))
 {
  if ((ch == '/n') || (ch == ' '))
  { 
   while (curr < len)
   {
    state = 0;
    while ((state != -1) && (curr < len))
    {
     state = DFATable->Transit(state, buf[curr], edge);
        if (AcceptStates[state] == 1)
     {
      outfile << "/nLn " << ln << ", Col " << bufHead <<": ";
      outfile.write(buf, curr+1);
         count++;
     }
     curr++;
    }
    RemoveFirstSymbol(buf, len);
    bufHead++;
    curr = 0;
   }
   if (ch == '/n')
   {
    ln++;
    col = 0;
   }
   if (ch == ' ')
   {
    col++;
   }
  }
  else
  {
   col++;
   if (len == 0)
   {
    bufHead = col;
   }
   buf[len++] = ch;
   if (len >= 256)
   {
    cout << "读取字符串的长度超过最大限额！" << endl;
    getch();
    exit(1);
   }
  }
 }
 while (curr < len)
 {
  state = 0;
    curr = 0;
  while ((state != -1) && (curr < len))
  {
   state = DFATable->Transit(state, buf[curr], edge);
      if (AcceptStates[state] == 1)
   {
    outfile << "/nLn " << ln << ", Col " << bufHead <<": ";
    outfile.write(buf, curr+1);
       count++;
   }
   curr++;
  }
  RemoveFirstSymbol(buf, len);
  bufHead++;
 }
 if (count > 0)
 {
  outfile << "/n/n一共找到" << count << "匹配字符串";
 }
 else
 {
  outfile << "/n/n没有找到任何匹配字符串";
 }
 infile.close();
 outfile.close();
 cout << "/n查找结果已保存在" << filePath << "中/n"
      << "/n------------------------" << endl;
}

//=====================================================

// 主函数
void main()
{
 DFA dfa;
 dfa.GetRegExp();
 dfa.InsertCatNode();
 dfa.RegExpToPost();
 dfa.GetEdgeNumber();
 dfa.ThompsonConstruction();
 dfa.SubsetConstruction();
 dfa.FindMatchingPatternInFile();
}

//=====================================================

 

sangzixuetong
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
c++ setstate() 和　clear() 函数
digitalkee的博客
04-21 1415
#include <iostream> #include <string> using namespace std; int main() { auto st1 = cin.rdstate(); //记住cin流的原始状态 cout << "old state of stream is: "<< st1 << ...
【编译原理】实验三 NFA 确定化和 DFA 最小化
热门推荐
qq_36326434的博客
03-06 1万+
一、实验标题：NFA确定化和DFA最小化 二、实验目的：1. 学习和掌握将NFA转为DFA的子集构造法。2. 学会编程实现等价划分法最小化DFA。 三、实验内容：（一）NFA确定化（1）确定NFA与DFA的存储格式。要求为3个以上测试NFA准备好相应有限自动机的存储文件。（2）用C或JAVA语言编写将NFA转换成DFA的子集构造法的程序。（3）测试验证程序的正确性。（4）测试用例参考：将下列语言用...
[编译原理随记]最小化DFA
qq_28033719的博客
06-29 1296
上级文章： [编译原理随记]正则表达式构建DFA(r(#)followpos(i)构造)：https://blog.csdn.net/qq_28033719/article/details/117561604 先准备需要进行简化的 DFA 状态图 它对应的 DFA 状态转换表 (Dtran) 是： 优化状态数 然后进行拆分区别： 1、先把所有状态放到一组内 2、第一次区分是区分接受状态和非接受状态，如果接受状态是一个，那么接收状态为一组，多个就多组，其他归为非接受状态。 3、然后第一
编译原理 词法分析
Jinbao
04-20 5054
原文地址：编译原理 词法分析 编译原理词法分析词法分析的主要任务是从左至右逐个字符地对源程序进行扫描，产生一个个单词序列，用于语法分析。 1.正则表达式对给定的字符集∑={c1,c2,...,cn},归纳定义： 1.空串ε是正则表达式 2.对于任意c∈∑，c是正则表达式 3.如果M和N是正则表达式，则下列表达式也是正则表达式 (1)选择 M|N={M,N} (2)连接 MN={mn|m∈M,n∈N
接上一篇
qq_37620268的博客
08-09 120
接上一篇称重模块 ​ 显示处理 ，我是采用的在手机显示的方式，作为一个预警模式，手头上没有IOT模块，这里就先用一个WIFI模块先写了一个，上位机采用的安卓软件。WIFI模块的话采用的8266， ​ 关于esp8266开发的目前我见过 LUA，SDK，arduino，我在此处采用的是arduino开发模式，在下载arduino开发环境后需要配置，关于esp8266的配置可以去看<...
词法分析器
ZZU_DF的专栏
05-11 2686
实验一  源程序的预处理及词法分析程序设计 （6学时） 一、 实验目的 设计并实现一个包含预处理功能的词法分析程序，加深对编译中词法分析过程的理解。 二、 实验要求 1、实现预处理功能 源程序中可能包含有对程序执行无意义的符号，要求将其剔除。 首先编制一个源程序的输入过程，从键盘、文件或文本框输入若干行语句，依次存入输入缓冲区（字符型数据）；然后编制一个预处理子程序，去掉输入串中的回
南华大学编译原理实验 词法分析器代码报告+语法分析器+期末复习PPT
05-10
本篇将深入探讨南华大学编译原理实验中的词法分析器和语法分析器的设计，并结合期末复习PPT，全面解析这一领域的关键知识点。 一、词法分析 词法分析，也称扫描器或词法生成器，是编译器的第一步。它的主要任务是...
如何用python写一个简单的词法分析器
09-19
本篇介绍了一种使用Python实现简单词法分析器的方法。通过预处理、词汇表构建、逐行扫描、辨识与分类以及结果输出等步骤，我们能够有效地解析输入文本，并识别其中的关键元素。这种方法不仅适用于学习词法分析的基本...
C语言词法分析器
06-16
本篇文章将深入探讨如何使用C语言来实现一个词法分析器，主要关注实验目的、实验内容、实验要求以及源程序代码的解析。 一、实验目的 1. 通过实践加深对词法分析原理的理解，包括词法规则和基本实现技术。 2. 巩固...
词法分析器描述文档1
08-08
词法分析器是编译器前端的关键组成部分，其主要任务是将源代码转换为一系列有意义的词法单元（Token），以便后续的语法分析和语义分析。本篇文档描述了一个词法分析器的设计与实现，重点在于如何通过正则表达式、DFA...
Go---环形链表
weixin_47328424的博客
01-28 864
完成对单向环形链表的添加结点，册除结点和显示. package main import ( "fmt" ) //定义猫的结构体的结点 type CatNode struct { Num int //猫的编号 Name string Next *CatNode //指向下一个结点 } //添加结点 func InsertCatNode(head *CatNode,newCatNode *CatNode){ //判断是不是添加第一只猫 ...
编译原理笔记
一只小杰鸽的博客
05-11 2892
编译原理笔记 文章目录编译原理笔记第一章 引论1.1 语言处理器1.2 一个编译器的结构第二章 一个简单的语法制导翻译器2.7 符号表2.7.1 为每个作用域设置一个符号表2.7.2 符号表的使用第三章 词法分析3.1 词法分析器的作用3.1.1 词法分析及语法分析3.1.2 词法单元、模式和词素3.1.3 词法单元的属性3.1.4 词法错误3.2 输入缓冲3.2.1 缓冲区对3.2.2 哨兵标记3.3 词法单元的规约3.3.1 串和语言3.3.2 语言上的运算3.3.3 正则表达式3.3.4 正则定义3
一文入门：正则表达式基础
H_Hyyy的博客
08-19 310
正则表达式是一个强大的工具，但也需要一定的学习曲线。通过不断实践和使用，你将能够掌握这一强大的文本处理技能。
练习题 - 探索正则表达式re功能
Mr数据杨
08-15 167
通过这个练习，你学会了如何使用正则表达式从文本中提取电子邮件地址，这在数据整理和信息提取时非常有用。
一文入门re 正则表达式
最新发布
weixin_66722017的博客
08-19 252
一般使用方法第一个参数：正则模式第二个参数：需要处理的字符串第三个参数：附加处理方法result从任意位置开始匹配，返回match，没有匹配到返回Nonefindall以列表的形式返回所有匹配到的字符串match从第一个字符开始匹配，如果第一个字符不匹配，就返回Nonefullmatch匹配整个字符串，返回match或Nonefinditer返回迭代器,每一个元素都是Match。
Ciallo～(∠・ω・ )⌒☆第二十一篇 入门re 正则表达式
m0_69479843的博客
08-19 146
re.search(pattern, string)：在字符串中搜索匹配模式的第一个位置，如果匹配成功，则返回一个匹配对象，否则返回None。re.match(pattern, string)：从字符串的开始位置匹配一个模式，如果匹配成功，则返回一个匹配对象，否则返回None。re.findall(pattern, string)：在字符串中搜索匹配模式的所有位置，并以列表形式返回所有匹配的字符串。使用re模块，可以通过正则表达式来匹配、查找、替换字符串。{n} 匹配n次,{m，n} 匹配m-n次,
C/C++实现的C语言词法分析器设计探讨
"这篇论文是关于基于C/C++的C语言词法分析器的设计与实现，作者属于2007级计算机科学与技术专业，由一位讲师指导，完成于2011年2月-5月。论文主要讨论了C语言编译器的发展历程、使用的开发工具Visual Studio C++ ...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值