这是今天我的论文测试中的一个问题，函数签名是
int is_match(char* pattern,char* string)
该模式仅限于ASCII字符和量化*和?，因此它相对简单。 is_match如果匹配则应返回1，否则返回0。
我该怎么做？
答案 0 :(得分：6)
Brian Kernighan提供了一篇关于A Regular Expression Matcher的简短文章Rob Pike作为他们正在撰写的一本书的演示程序。这篇文章是一篇非常好的读物，解释了一般的代码和正则表达式。
我已经使用了这段代码，进行了一些更改以尝试一些扩展，例如还返回模式匹配的字符串中的位置，以便可以从原始文本中复制匹配模式的子字符串。
来自文章：
我向Rob建议我们需要找到最小的常规 表达式包，可以说明基本的想法 认识到一种有用且非平凡的模式。理想情况下， 代码适合单个页面。
罗布消失在他的办公室里，至少我现在还记得， 在30行C中，不超过一个小时或两个小时出现 后来出现在TPOP第9章的代码。那段代码 实现了一个处理这些结构的正则表达式匹配器：c matches any literal character c . matches any single character ^ matches the beginning of the input string $ matches the end of the input string * matches zero or more occurrences of the previous character这是一个非常有用的课程;根据我自己使用常规的经验 在日常情况下，它很容易占95％ 所有实例。在许多情况下，解决正确的问题是一个 迈向美好计划的重要一步。 Rob值得称赞 如此明智地选择，从众多选项中选择，非常小 但重要的，定义明确且可扩展的功能集。
Rob的实现本身就是漂亮代码的极好例子： 紧凑，优雅，高效，实用。这是最好的例子之一 我所见过的递归，它显示了C的力量 指针。虽然当时我们最感兴趣的是传达 一个好的符号在使程序更容易的重要作用 使用也许更容易编写正则表达式代码 也是说明算法，数据的绝佳方式 结构，测试，性能增强等重要 主题。
文章中的实际C源代码非常好。
/* match: search for regexp anywhere in text */
int match(char *regexp, char *text)
{
if (regexp[0] == '^')
return matchhere(regexp+1, text);
do { /* must look even if string is empty */
if (matchhere(regexp, text))
return 1;
} while (*text++ != '\0');
return 0;
}
/* matchhere: search for regexp at beginning of text */
int matchhere(char *regexp, char *text)
{
if (regexp[0] == '\0')
return 1;
if (regexp[1] == '*')
return matchstar(regexp[0], regexp+2, text);
if (regexp[0] == '$' && regexp[1] == '\0')
return *text == '\0';
if (*text!='\0' && (regexp[0]=='.' || regexp[0]==*text))
return matchhere(regexp+1, text+1);
return 0;
}
/* matchstar: search for c*regexp at beginning of text */
int matchstar(int c, char *regexp, char *text)
{
do { /* a * matches zero or more instances */
if (matchhere(regexp, text))
return 1;
} while (*text != '\0' && (*text++ == c || c == '.'));
return 0;
}
答案 1 :(得分：5)
有关您无法提交的解决方案，请参阅This Question。有关如何实现更具可读性的说明，请参阅this paper。
答案 2 :(得分：4)
这是递归可扩展的实现。测试了模式复杂性的第一顺序。
#include <string.h>
#include <string>
#include <vector>
#include <iostream>
struct Match {
Match():_next(0) {}
virtual bool match(const char * pattern, const char * input) const {
return !std::strcmp(pattern, input);
}
bool next(const char * pattern, const char * input) const {
if (!_next) return false;
return _next->match(pattern, input);
}
const Match * _next;
};
class MatchSet: public Match {
typedef std::vector<Match *> Set;
Set toTry;
public:
virtual bool match(const char * pattern, const char * input) const {
for (Set::const_iterator i = toTry.begin(); i !=toTry.end(); ++i) {
if ((*i)->match(pattern, input)) return true;
}
return false;
}
void add(Match * m) {
toTry.push_back(m);
m->_next = this;
}
~MatchSet() {
for (Set::const_iterator i = toTry.begin(); i !=toTry.end(); ++i)
if ((*i)->_next==this) (*i)->_next = 0;
}
};
struct MatchQuestion: public Match {
virtual bool match(const char * pattern, const char * input) const {
if (pattern[0] != '?')
return false;
if (next(pattern+1, input))
return true;
if (next(pattern+1, input+1))
return true;
return false;
}
};
struct MatchEmpty: public Match {
virtual bool match(const char * pattern, const char * input) const {
if (pattern[0]==0 && input[0]==0)
return true;
return false;
}
};
struct MatchAsterisk: public Match {
virtual bool match(const char * pattern, const char * input) const {
if (pattern[0] != '*')
return false;
if (pattern[1] == 0) {
return true;
}
for (int i = 0; input[i] != 0; ++i) {
if (next(pattern+1, input+i))
return true;
}
return false;
}
};
struct MatchSymbol: public Match {
virtual bool match(const char * pattern, const char * input) const {
// TODO: consider cycle here to prevent unnecessary recursion
// Cycle should detect special characters and call next on them
// Current implementation abstracts from that
if (pattern[0] != input[0])
return false;
return next(pattern+1, input+1);
}
};
class DefaultMatch: public MatchSet {
MatchEmpty empty;
MatchQuestion question;
MatchAsterisk asterisk;
MatchSymbol symbol;
public:
DefaultMatch() {
add(&empty);
add(&question);
add(&asterisk);
add(&symbol);
}
void test(const char * p, const char * input) const {
testOneWay(p, input);
if (!std::strcmp(p, input)) return;
testOneWay(input, p);
}
bool testOneWay(const char * p, const char * input) const {
const char * eqStr = " == ";
bool rv = match(p, input);
if (!rv) eqStr = " != ";
std::cout << p << eqStr << input << std::endl;
return rv;
}
};
int _tmain(int argc, _TCHAR* argv[])
{
using namespace std;
typedef vector<string> Strings;
Strings patterns;
patterns.push_back("*");
patterns.push_back("*hw");
patterns.push_back("h*w");
patterns.push_back("hw*");
patterns.push_back("?");
patterns.push_back("?ab");
patterns.push_back("a?b");
patterns.push_back("ab?");
patterns.push_back("c");
patterns.push_back("cab");
patterns.push_back("acb");
patterns.push_back("abc");
patterns.push_back("*this homework?");
patterns.push_back("Is this homework?");
patterns.push_back("This is homework!");
patterns.push_back("How is this homework?");
patterns.push_back("hw");
patterns.push_back("homework");
patterns.push_back("howork");
DefaultMatch d;
for (unsigned i = 0; i < patterns.size(); ++i)
for (unsigned j =i; j < patterns.size(); ++j)
d.test(patterns[i].c_str(), patterns[j].c_str());
return 0;
}
如果不清楚，请询问。
答案 3 :(得分：2)
尝试列出一些有趣的测试用例：
is_match（“虚拟”，“虚拟”）应该 return true;
is_match（“dumm？y”，“dummy”）应该 返回true;
is_match（ “达姆？Y”， “伪”） 应该返回false;
is_match（“dum * y”，“dummy”）应该 return true;
依旧......
然后看看如何使更简单的测试通过，然后是下一个......
答案 4 :(得分：2)
作弊。使用#include <boost/regex/regex.hpp>。
答案 5 :(得分：1)
没有测试过，实际编码或调试它，但这可能会让你开始......
for each character in the pattern
if pattern character after the current one is *
// enter * state
while current character from target == current pattern char, and not at end
get next character from target
skip a char from the pattern
else if pattern character after the current one is ?
// enter ? state
if current character from target == current pattern char
get next char from target
skip a char from the pattern
else
// enter character state
if current character from target == current pattern character
get next character from target
else
return false
return true
答案 6 :(得分：1)
解决此问题不需要正则表达式和有限状态机的全部功能。作为替代方案，存在相对简单的动态编程解决方案。
如果可以将子字符串 string [i..n-1]与子模式模式匹配，则匹配（i，j）为1 [j，m - 1]，其中n和m分别是 string 和 pattern 的长度。否则让匹配（i，j）为0.
基本案例是：
match（n，m）= 1，您可以将空字符串与空图案匹配;
match（i，m）= 0，您无法将非空字符串与空模式匹配;
转换分为3种情况，具体取决于当前子模式是以字符后跟'*'开头，还是字符后跟'？'或者只是以一个没有特殊符号的字符开头。
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int is_match(char* pattern, char* string)
{
int n = strlen(string);
int m = strlen(pattern);
int i, j;
int **match;
match = (int **) malloc((n + 1) * sizeof(int *));
for(i = 0; i <= n; i++) {
match[i] = (int *) malloc((m + 1) * sizeof(int));
}
for(i = n; i >= 0; i--) {
for(j = m; j >= 0; j--) {
if(i == n && j == m) {
match[i][j] = 1;
}
else if(i < n && j == m) {
match[i][j] = 0;
}
else {
match[i][j] = 0;
if(pattern[j + 1] == '*') {
if(match[i][j + 2]) match[i][j] = 1;
if(i < n && pattern[j] == string[i] && match[i + 1][j]) match[i][j] = 1;
}
else if(pattern[j + 1] == '?') {
if(match[i][j + 2]) match[i][j] = 1;
if(i < n && pattern[j] == string[i] && match[i + 1][j + 2]) match[i][j] = 1;
}
else if(i < n && pattern[j] == string[i] && match[i + 1][j + 1]) {
match[i][j] = 1;
}
}
}
}
int result = match[0][0];
for(i = 0; i <= n; i++) {
free(match[i]);
}
free(match);
return result;
}
int main(void)
{
printf("is_match(dummy, dummy) = %d\n", is_match("dummy","dummy"));
printf("is_match(dumm?y, dummy) = %d\n", is_match("dumm?y","dummy"));
printf("is_match(dum?y, dummy) = %d\n", is_match("dum?y","dummy"));
printf("is_match(dum*y, dummy) = %d\n", is_match("dum*y","dummy"));
system("pause");
return 0;
}
这种方法的时间复杂度是O（n * m）。存储器复杂度也是O（n * m），但是简单的修改可以减少到O（m）。
答案 7 :(得分：0)
简单的递归实现。这很慢但很容易理解：
int is_match(char *pattern, char *string)
{
if (!pattern[0]) {
return !string[0];
} else if (pattern[1] == '?') {
return (pattern[0] == string[0] && is_match(pattern+2, string+1))
|| is_match(pattern+2, string);
} else if (pattern[1] == '*') {
size_t i;
for (i=0; string[i] == pattern[0]; i++)
if (is_match(pattern+2, string+i)) return 1;
return 0;
} else {
return pattern[0] == string[0] && is_match(pattern+1, string+1);
}
}
希望我没事。
答案 8 :(得分：0)
用于查找索引的C程序，主字符串中的子字符串将从该处开始。 在这里输入代码
#include<stdio.h>
int mystrstr (const char *,const char *);
int mystrcmp(char *,char *);
int main()
{
char *s1,*s2;//enter the strings, s1 is main string and s2 is substring.
printf("Index is %d\n",mystrstr(s1,s2));
//print the index of the string if string is found
}
//search for the sub-string in the main string
int mystrstr (const char *ps1,const char *ps2)
{
int i=0,j=0,c=0,l,m;char *x,*y;
x=ps1;
y=ps2;
while(*ps1++)i++;
while(*ps2++)j++;
ps1=x;
ps2=y;
char z[j];
for(l=0;l<i-j;l++)
{
for(m=l;m<j+l;m++)
//store the sub-string of similar size from main string
z[c++]=ps1[m];
z[c]='\0'
c=0;
if(mystrcmp(z,ps2)==0)
break;
}
return l;
}
int mystrcmp(char *ps3,char *ps4) //compare two strings
{
int i=0;char *x,*y;
x=ps3;y=ps4;
while((*ps3!=0)&&(*ps3++==*ps4++))i++;
ps3=x;ps4=y;
if(ps3[i]==ps4[i])
return 0;
if(ps3[i]>ps4[i])
return +1;
else
return -1;
}