9

笔记

下面的问题是在 2008 年提出的关于 2003 年的一些代码的问题。正如 OP 的更新所显示的那样，整个帖子已被 2008 年的老式算法所淘汰，并且仅作为历史好奇心保留在这里。

我需要在 C/C++ 中进行快速不区分大小写的子字符串搜索。我的要求如下：

  • 应该表现得像 strstr() （即返回一个指向匹配点的指针）。
  • 必须不区分大小写 (doh)。
  • 必须支持当前语言环境。
  • 必须在 Windows (MSVC++ 8.0) 上可用或易于移植到 Windows（即来自开源库）。

这是我正在使用的当前实现（取自 GNU C 库）：

/* Return the offset of one string within another.
   Copyright (C) 1994,1996,1997,1998,1999,2000 Free Software Foundation, Inc.
   This file is part of the GNU C Library.

   The GNU C Library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.

   The GNU C Library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with the GNU C Library; if not, write to the Free
   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
   02111-1307 USA.  */

/*
 * My personal strstr() implementation that beats most other algorithms.
 * Until someone tells me otherwise, I assume that this is the
 * fastest implementation of strstr() in C.
 * I deliberately chose not to comment it.  You should have at least
 * as much fun trying to understand it, as I had to write it :-).
 *
 * Stephen R. van den Berg, berg@pool.informatik.rwth-aachen.de */

/*
 * Modified to use table lookup instead of tolower(), since tolower() isn't
 * worth s*** on Windows.
 *
 * -- Anders Sandvig (anders@wincue.org)
 */

#if HAVE_CONFIG_H
# include <config.h>
#endif

#include <ctype.h>
#include <string.h>

typedef unsigned chartype;

char char_table[256];

void init_stristr(void)
{
  int i;
  char string[2];

  string[1] = '\0';
  for (i = 0; i < 256; i++)
  {
    string[0] = i;
    _strlwr(string);
    char_table[i] = string[0];
  }
}

#define my_tolower(a) ((chartype) char_table[a])

char *
my_stristr (phaystack, pneedle)
     const char *phaystack;
     const char *pneedle;
{
  register const unsigned char *haystack, *needle;
  register chartype b, c;

  haystack = (const unsigned char *) phaystack;
  needle = (const unsigned char *) pneedle;

  b = my_tolower (*needle); 
  if (b != '\0')
  {
    haystack--;             /* possible ANSI violation */
    do
      {
        c = *++haystack;
        if (c == '\0')
          goto ret0;
      }
    while (my_tolower (c) != (int) b);

    c = my_tolower (*++needle);
    if (c == '\0')
        goto foundneedle;

    ++needle;
    goto jin;

    for (;;)
    {
      register chartype a;
        register const unsigned char *rhaystack, *rneedle;

        do
        {
          a = *++haystack;
          if (a == '\0')
              goto ret0;
          if (my_tolower (a) == (int) b)
              break;
          a = *++haystack;
          if (a == '\0')
              goto ret0;
        shloop:
          ;
        }
      while (my_tolower (a) != (int) b);

jin:      
      a = *++haystack;
      if (a == '\0')
          goto ret0;

        if (my_tolower (a) != (int) c)
          goto shloop;

        rhaystack = haystack-- + 1;
        rneedle = needle;

        a = my_tolower (*rneedle);

        if (my_tolower (*rhaystack) == (int) a)
          do
          {
              if (a == '\0')
                goto foundneedle;

              ++rhaystack;
          a = my_tolower (*++needle);
              if (my_tolower (*rhaystack) != (int) a)
                break;

          if (a == '\0')
                goto foundneedle;

          ++rhaystack;
              a = my_tolower (*++needle);
          }
          while (my_tolower (*rhaystack) == (int) a);

        needle = rneedle;       /* took the register-poor approach */

      if (a == '\0')
          break;
    }
  }
foundneedle:
  return (char*) haystack;
ret0:
  return 0;
}

你能让这段代码更快吗，或者你知道更好的实现吗？

注意：我注意到 GNU C 库现在有一个新的实现strstr()，但我不确定它是否可以轻松地修改为不区分大小写，或者它实际上是否比旧的更快（在我的情况下）。我还注意到旧的实现仍然用于宽字符串，所以如果有人知道为什么，请分享。

更新

只是为了让事情清楚——以防它还没有——我没有编写这个函数，它是 GNU C 库的一部分。我只是将其修改为不区分大小写。

另外，感谢有关strcasestr()其他来源（如 OpenBSD、FreeBSD 等）的其他实现的提示和检查。这似乎是要走的路。上面的代码来自 2003 年，这就是为什么我在这里发布它以希望有更好的版本可用，显然是这样。:)

4

10 回答 10

13

您发布的代码大约是strcasestr. 

$ gcc -Wall -o my_stristr my_stristr.c
steve@solaris:~/code/tmp
$ gcc -Wall -o strcasestr strcasestr.c 
steve@solaris:~/code/tmp
$ ./bench ./my_stristr > my_stristr.result ; ./bench ./strcasestr > strcasestr.result;
steve@solaris:~/code/tmp
$ cat my_stristr.result 
run 1... time = 6.32
run 2... time = 6.31
run 3... time = 6.31
run 4... time = 6.31
run 5... time = 6.32
run 6... time = 6.31
run 7... time = 6.31
run 8... time = 6.31
run 9... time = 6.31
run 10... time = 6.31
average user time over 10 runs = 6.3120
steve@solaris:~/code/tmp
$ cat strcasestr.result 
run 1... time = 3.82
run 2... time = 3.82
run 3... time = 3.82
run 4... time = 3.82
run 5... time = 3.82
run 6... time = 3.82
run 7... time = 3.82
run 8... time = 3.82
run 9... time = 3.82
run 10... time = 3.82
average user time over 10 runs = 3.8200
steve@solaris:~/code/tmp

main功能是 ：

int main(void)
{
        char * needle="hello";
        char haystack[1024];
        int i;

        for(i=0;i<sizeof(haystack)-strlen(needle)-1;++i)
        {
                haystack[i]='A'+i%57;
        }
        memcpy(haystack+i,needle, strlen(needle)+1);
        /*printf("%s\n%d\n", haystack, haystack[strlen(haystack)]);*/
        init_stristr();

        for (i=0;i<1000000;++i)
        {
                /*my_stristr(haystack, needle);*/
                strcasestr(haystack,needle);
        }


        return 0;
}

它经过适当修改以测试两种实现。我注意到，当我输入这个时，我在init_stristr通话中留下了，但它不应该改变太多。bench只是一个简单的shell脚本：

#!/bin/bash
function bc_calc()
{
        echo $(echo "scale=4;$1" | bc)
}
time="/usr/bin/time -p"
prog="$1"
accum=0
runs=10
for a in $(jot $runs 1 $runs)
do
        echo -n "run $a... "
        t=$($time $prog 2>&1| grep user | awk '{print $2}')
        echo "time = $t"
        accum=$(bc_calc "$accum+$t")
done

echo -n "average user time over $runs runs = "
echo $(bc_calc "$accum/$runs")
于 2008-10-17T11:56:02.560 回答
6

您可以使用 StrStrI 函数来查找字符串中第一次出现的子字符串。比较不区分大小写。不要忘记包含它的标题 - Shlwapi.h。看看这个：http: //msdn.microsoft.com/en-us/library/windows/desktop/bb773439 (v=vs.85).aspx

于 2014-02-06T06:06:53.560 回答
3

使用提升字符串算法。它是可用的，跨平台的，并且只有一个头文件（没有要链接的库）。更不用说你应该使用 boost 。

#include <boost/algorithm/string/find.hpp>

const char* istrstr( const char* haystack, const char* needle )
{
   using namespace boost;
   iterator_range<char*> result = ifind_first( haystack, needle );
   if( result ) return result.begin();

   return NULL;
}
于 2008-10-17T19:28:29.260 回答
3

对于平台独立使用：

const wchar_t *szk_wcsstri(const wchar_t *s1, const wchar_t *s2)
{
    if (s1 == NULL || s2 == NULL) return NULL;
    const wchar_t *cpws1 = s1, *cpws1_, *cpws2;
    char ch1, ch2;
    bool bSame;

    while (*cpws1 != L'\0')
    {
        bSame = true;
        if (*cpws1 != *s2)
        {
            ch1 = towlower(*cpws1);
            ch2 = towlower(*s2);

            if (ch1 == ch2)
                bSame = true;
        }

        if (true == bSame)
        {
            cpws1_ = cpws1;
            cpws2 = s2;
            while (*cpws1_ != L'\0')
            {
                ch1 = towlower(*cpws1_);
                ch2 = towlower(*cpws2);

                if (ch1 != ch2)
                    break;

                cpws2++;

                if (*cpws2 == L'\0')
                    return cpws1_-(cpws2 - s2 - 0x01);
                cpws1_++;
            }
        }
        cpws1++;
    }
    return NULL;
}
于 2016-05-23T23:57:36.340 回答
2

你为什么使用 _strlwr(string); 在 init_stristr() 中？这不是标准功能。大概是为了支持语言环境，但由于它不是标准的，我只会使用：

char_table[i] = tolower(i);
于 2008-10-17T09:39:45.173 回答
1

我建议您采用一些已经存在的常见 strcasestr 实现。例如 glib、glibc、OpenBSD、FreeBSD 等。您可以通过 google.com/codesearch 搜索更多内容。然后，您可以进行一些性能测量并比较不同的实现。

于 2008-10-17T10:37:56.790 回答
1

假设两个输入字符串都已经小写。

int StringInStringFindFirst(const char* p_cText, const char* p_cSearchText)
{
    int iTextSize = strlen(p_cText);
    int iSearchTextSize = strlen(p_cSearchText);

    char* p_cFound = NULL;

    if(iTextSize >= iSearchTextSize)
    {
        int iCounter = 0;
        while((iCounter + iSearchTextSize) <= iTextSize)
        {
            if(memcmp( (p_cText + iCounter), p_cSearchText, iSearchTextSize) == 0)
                return  iCounter;
            iCounter ++;
        }
    }

    return -1;
}

您也可以尝试使用掩码...例如，如果您要比较的大多数字符串仅包含从 a 到 z 的字符，那么可能值得做这样的事情。

long GetStringMask(const char* p_cText)
{
    long lMask=0;

    while(*p_cText != '\0')
    {       
        if (*p_cText>='a' && *p_cText<='z')
            lMask = lMask | (1 << (*p_cText - 'a') );
        else if(*p_cText != ' ')
        {
            lMask = 0;
            break;      
        }

        p_cText ++;
    }
    return lMask;
}

然后...

int main(int argc, char* argv[])
{

    char* p_cText = "this is a test";   
    char* p_cSearchText = "test";

    long lTextMask = GetStringMask(p_cText);
    long lSearchMask = GetStringMask(p_cSearchText);

    int iFoundAt = -1;
    // If Both masks are Valid
    if(lTextMask != 0 && lSearchMask != 0)
    {
        if((lTextMask & lSearchMask) == lSearchMask)
        {       
             iFoundAt = StringInStringFindFirst(p_cText, p_cSearchText);
        }
    }
    else
    {
        iFoundAt = StringInStringFindFirst(p_cText, p_cSearchText);
    }


    return 0;
}
于 2008-10-17T12:12:48.920 回答
1

这不会考虑语言环境，但是如果您可以更改 IS_ALPHA 和 TO_UPPER，则可以考虑它。

#define IS_ALPHA(c) (((c) >= 'A' && (c) <= 'Z') || ((c) >= 'a' && (c) <= 'z'))
#define TO_UPPER(c) ((c) & 0xDF)

char * __cdecl strstri (const char * str1, const char * str2){
        char *cp = (char *) str1;
        char *s1, *s2;

        if ( !*str2 )
            return((char *)str1);

        while (*cp){
                s1 = cp;
                s2 = (char *) str2;

                while ( *s1 && *s2 && (IS_ALPHA(*s1) && IS_ALPHA(*s2))?!(TO_UPPER(*s1) - TO_UPPER(*s2)):!(*s1-*s2))
                        ++s1, ++s2;

                if (!*s2)
                        return(cp);

                ++cp;
        }
        return(NULL);
}
于 2013-04-02T07:50:46.727 回答
0

如果您想减少 CPU 周期，您可能会考虑这一点 - 假设我们正在处理 ASCII 而不是 Unicode。

制作一个包含 256 个条目的静态表。表中的每个条目都是 256 位。

要测试两个字符是否相等，请执行以下操作：

if (BitLookup(table[char1], char2)) { /* match */ }

要构建表，您在 table[char1] 中的任何位置都设置了一点，您认为它与 char2 匹配。因此，在构建表时，您将在“a”条目（和“A”条目）中设置“a”和“A”的索引位。

现在进行位查找会变慢（位查找很可能是移位、掩码和相加），因此您可以使用字节表代替，因此您可以使用 8 位来表示 1 位。这将需要 32K - 所以万岁 - 你已经达到了时间/空间的权衡！我们可能想让表格更灵活，所以假设我们这样做 - 表格将改为定义同余。

当且仅当存在将它们定义为等效的函数时，才认为两个字符是全等的。所以'A'和'a'对于不区分大小写是一致的。'A'、'À'、'Á' 和 'Â' 对于变音不敏感是一致的。

所以你定义对应于你的一致性的位域

#define kCongruentCase (1 << 0)
#define kCongruentDiacritical (1 << 1)
#define kCongruentVowel (1 << 2)
#define kCongruentConsonant (1 << 3)

那么你的测试是这样的：

inline bool CharsAreCongruent(char c1, char c2, unsigned char congruency)
{
    return (_congruencyTable[c1][c2] & congruency) != 0;
}

#define CaseInsensitiveCharEqual(c1, c2) CharsAreCongruent(c1, c2, kCongruentCase)

这种对巨大表格的摆弄是 ctype 的核心。

于 2008-10-17T13:36:56.943 回答
0

如果您可以控制针字符串，使其始终为小写，那么您可以编写 stristr() 的修改版本以避免查找，从而加快代码速度。它不是一般的，但它可以更快 - 稍微快一点。类似的评论适用于 haystack，但您更有可能从您无法控制的来源读取 haystack，因为您无法确定数据是否满足要求。

性能上的提升是否值得完全是另一个问题。对于 99% 的应用程序，答案是“不，不值得”。您的应用程序可能是少数重要的应用程序之一。更有可能的是，事实并非如此。

于 2008-10-19T06:56:39.010 回答