看看str系列函数的实现一

最新推荐文章于 2022-05-09 18:50:45 发布

tianjieshui

最新推荐文章于 2022-05-09 18:50:45 发布

阅读量2k

点赞数

本文链接：https://blog.csdn.net/tianjieshui/article/details/1968281

版权

很多面试题都会提到自己来实现一个函数,strcmp,strcpy,strstr……
我们来看一下一下函数的实现：

int
strcmp (p1, p2)
const char *p1;
const char *p2;
{
register const unsigned char *s1 = (const unsigned char *) p1;
//register 表示向编译器建议使用高速寄存器存储变量
//const 表示指向的字符串不被修改
//unsigned 表示支持unicode字符
//char 就不用说了^_^
register const unsigned char *s2 = (const unsigned char *) p2;
unsigned reg_char c1, c2;

do
    {
      c1 = (unsigned char) *s1++;
      c2 = (unsigned char) *s2++;
      if (c1 == '/0')
return c1 - c2;//比较的精华所在
    }
while (c1 == c2);

return c1 - c2;
}
早上偶想了一上午看了这个代码才知道差距所在,do while 语句莫有想到 c1-c2 也莫有想到.

下面来看个稍微复杂点的,strstr,偶们公司面试经常出这道题,不少所谓的英雄好汉折戟沉沙于此,其实不最求效率的话,
两个for循环也可以搞定,最求效率就要看这个了.

typedef unsigned chartype;

char *
strstr (phaystack, pneedle)
      const char * phaystack;
      const char * pneedle;
{
   const unsigned char * haystack, * needle;
  chartype b;
   const unsigned char * rneedle;

  haystack = ( const unsigned char * ) phaystack;

   if ((b = * (needle = ( const unsigned char * ) pneedle)))
    {
      chartype c;
      haystack -- ;   /* possible ANSI violation */
// 这个是为了后面*++haystack 否则第一位获取不到
      {
chartype a;
do
    if ( ! (a = *++ haystack)) // 如果无法赋值,说明phaystack是空字符串
      goto ret0;
while (a != b); // 找到第一个ab字符串相等的位置
      }

       if ( ! (c = *++ needle)) // 比较字符串向后移一位
goto foundneedle; // 如果无法赋值说明比较字符串只有一位,返回比较得到的位置
       ++ needle; // 很疑惑这里卫生么要+1,但是看到后面jin部分的代码,c的值已经做过保存,+1用得很漂亮
       goto jin;

       for (;;)
{
   {
     chartype a; // 这个定义也是非常的搞,卫生么不定义在函数开头?
      if ( 0 ) // 下面的jin:就是说在for循环内永远无法执行,但是可以被跳转
     jin:{
   if ((a = *++ haystack) == c) // 如果两个相等则比较剩余字符
     goto crest;
       }
      else
       a = *++ haystack; // 赋值
      do
       {
   for (; a != b; a = *++ haystack) // b是比较字符串的第一位 c是第二位
    {
       if ( ! a)
         goto ret0;
       if ((a = *++ haystack) == b) // 第一位相等
         break ;
       if ( ! a)
         goto ret0;
    }
       }
      while ((a = *++ haystack) != c); // 如果能够跳出这个循环说明第二位也相等
   }
crest: // 从第三位开始处理
   {
     chartype a;
     {
        const unsigned char * rhaystack;
        if ( * (rhaystack = haystack -- + 1 ) == (a = * (rneedle = needle))) // 如果当前的字符相等
   do
    {
       if ( ! a) // 如果a==0 表示到了字符串尾
         goto foundneedle;
       if ( *++ rhaystack != (a = *++ needle)) // 如果下一位不等跳出 do while循环
         break ;
       if ( ! a) // 如果a==0 表示到了字符串尾
         goto foundneedle;
    }
   while ( *++ rhaystack == (a = *++ needle)); // 如果相等继续比较
       needle = rneedle; /* took the register-poor aproach */
     // 到了这里表示比较失败需要回溯 needle 指针回到原来的值
     }
      if ( ! a) // 如果a==0 跳出for循环会直接到foundneedle 标签所以如果使用goto foundneedle; 我想也没有什么关系
        break ;
   }
}
    }
foundneedle:
   return ( char * ) haystack;
ret0:
   return 0 ;
}

看完这段代码,莫有惊喜,从作者自信满满的口气中(Until someone tells me otherwise, I assume that this is the
fastest implementation of strstr() in C),我还以为至少效率会超过kmp的,看完以后,这只不过是个精巧的回溯算法罢了,
多次用到的go to 也末有什么特色,不过这个人很有意思的一点是不写注释也就罢了,还要故意说出来(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 :-).) 鄙视你

附另一个人写的,貌似加州大学的一个教授应该是solaris上的实现

char     *
  strstr( string ,   substring)
          register    char     * string ;              /*    String   to   search.    */
           char     * substring;                          /*    Substring   to   try   to   find   in   string.    */
  {
          register    char     * a,    * b;

           /*    First   scan   quickly   through   the   two   strings   looking   for   a
              *   single-character   match.     When   it's   found,   then   compare   the
            *   rest   of   the   substring.
             */

          b    =    substring;
           if    ( * b    ==     0 )   {
                   return     string ;
          } // 如果查找字符串不存在直接返回string
           for    (   ;    * string     !=     0 ;    string     +=     1 )   {
                   if    ( * string     !=     * b)   {   // 如果第一位不相等比较下一位
                           continue ;
                  }
                  a    =     string ;
                   while    ( 1 )   {
                           if    ( * b    ==     0 )   {   // 到了查找字符串结尾,说明已经找到
                                   return     string ;
                          }
                           if    ( * a ++     !=     * b ++ )   {   // 有不相同的,跳出循环
                                   break ;
                          }
                  }
                  b    =    substring;   // 恢复查找字符串
          }
           return    ( char     * )    0 ;
  }

这个算法看上去方方正正,冲正平和,让人一看上去就觉得程序就应该是这么写的,而你自己放手去写却写不出这个味道来,所谓大巧
不工,莫过于此.
同是回溯算法,我真的不认为第一个除了神叨叨的故弄玄虚了半天,效率上有多少提升.

再来看看strlen,偶自信满满的写了一个先:

size_t strlen(str)
const char * str;
{
register const unsigned char * s = str ;
while ( * s != 0 )
s ++ ;
return s - str ;
}

自我感觉相当良好,再看看人家写的,完全不懂! 我靠偶整整落后一百年!

/* Return the length of the null-terminated string STR. Scan for
the null terminator quickly by testing four bytes at a time. */
size_t
strlen (str)
const char *str;
{
const char *char_ptr;
const unsigned long int *longword_ptr;
unsigned long int longword, magic_bits, himagic, lomagic;

/* Handle the first few characters by reading one character at a time.
     Do this until CHAR_PTR is aligned on a longword boundary. */
for (char_ptr = str; ((unsigned long int) char_ptr
   & (sizeof (longword) - 1)) != 0;
       ++char_ptr)
    if (*char_ptr == '/0')
      return char_ptr - str;

/* All these elucidatory comments refer to 4-byte longwords,
but the theory applies equally well to 8-byte longwords. */

longword_ptr = (unsigned long int *) char_ptr;

/* Bits 31, 24, 16, and 8 of this number are zero. Call these bits
the "holes." Note that there is a hole just to the left of
each byte, with an extra at the end:

bits: 01111110 11111110 11111110 11111111
bytes: AAAAAAAA BBBBBBBB CCCCCCCC DDDDDDDD

     The 1-bits make sure that carries propagate to the next 0-bit.
     The 0-bits provide holes for carries to fall into. */
magic_bits = 0x7efefeffL;
himagic = 0x80808080L;
lomagic = 0x01010101L;
if (sizeof (longword) > 4)
    {
      /* 64-bit version of the magic. */
      /* Do the shift in two steps to avoid a warning if long has 32 bits. */
      magic_bits = ((0x7efefefeL << 16) << 16) | 0xfefefeffL;
      himagic = ((himagic << 16) << 16) | himagic;
      lomagic = ((lomagic << 16) << 16) | lomagic;
    }
if (sizeof (longword) > 8)
    abort ();

/* Instead of the traditional loop which tests each character,
     we will test a longword at a time. The tricky part is testing
     if *any of the four* bytes in the longword in question are zero. */
for (;;)
    {
      /* We tentatively exit the loop if adding MAGIC_BITS to
LONGWORD fails to change any of the hole bits of LONGWORD.

1) Is this safe? Will it catch all the zero bytes?
Suppose there is a byte with all zeros. Any carry bits
propagating from its left will fall into the hole at its
least significant bit and stop. Since there will be no
carry from its most significant bit, the LSB of the
byte to the left will be unchanged, and the zero will be
detected.

2) Is this worthwhile? Will it ignore everything except
zero bytes? Suppose every byte of LONGWORD has a bit set
somewhere. There will be a carry into bit 8. If bit 8
is set, this will carry into bit 16. If bit 8 is clear,
one of bits 9-15 must be set, so there will be a carry
into bit 16. Similarly, there will be a carry into bit
24. If one of bits 24-30 is set, there will be a carry
into bit 31, so all of the hole bits will be changed.

The one misfire occurs when bits 24-30 are clear and bit
31 is set; in this case, the hole at bit 31 is not
changed. If we had access to the processor carry flag,
we could close this loophole by putting the fourth hole
at bit 32!

So it ignores everything except 128's, when they're aligned
properly. */

longword = *longword_ptr++;

      if (
#if 0
   /* Add MAGIC_BITS to LONGWORD. */
   (((longword + magic_bits)

/* Set those bits that were unchanged by the addition. */
^ ~longword)

    /* Look at only the hole bits. If any of the hole bits
       are unchanged, most likely one of the bytes was a
       zero. */
    & ~magic_bits)
#else
   ((longword - lomagic) & himagic)
#endif
   != 0)
{
   /* Which of the bytes was the zero? If none of them were, it was
      a misfire; continue the search. */

const char *cp = (const char *) (longword_ptr - 1);

   if (cp[0] == 0)
     return cp - str;
   if (cp[1] == 0)
     return cp - str + 1;
   if (cp[2] == 0)
     return cp - str + 2;
   if (cp[3] == 0)
     return cp - str + 3;
   if (sizeof (longword) > 4)
     {
       if (cp[4] == 0)
  return cp - str + 4;
       if (cp[5] == 0)
  return cp - str + 5;
       if (cp[6] == 0)
  return cp - str + 6;
       if (cp[7] == 0)
  return cp - str + 7;
     }
}
    }
}