strlen的一个实现，估计1/3人看不明白

[pcboyxhy]

远非那么简单，不是简单的
while(*s!='\0') {
s++;
len++;
}

size_t
strlen (str)
     const char *str;
{
  const char *char_ptr;
  const unsigned long int *longword_ptr;
  unsigned long int longword, 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.  */
  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.  */
      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 (;;)
    {
      longword = *longword_ptr++;

      if (((longword - lomagic) & ~longword & himagic) != 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;
        }
    }
    }
}

[苍蝇①号]

库里面大多是通过汇编来实现的，x86种直接有对应的求长度的指令，速度比你这方法快不是一个等量级的

[whg01]

[Quote=引用 33 楼 cangyingzhijia 的回复:]
库里面大多是通过汇编来实现的，x86种直接有对应的求长度的指令，速度比你这方法快不是一个等量级的
[/Quote]
这个是比较通用的算法，具体到某个平台上，未必是最优，但至少达到了比较好的性能。
如果考虑到平台的特异性，那就得针对不同的平台，用不同的汇编了。
就像memcpy，最快的是DMA，但未必所有的平台都支持DMA。

[hiei1125]

路过 。。。

[玖伍叁柒]

1/3

[woods2001]

我靠，我看不懂！~~~

[Rain208]

[amossavez]

很强大呀！

[guihuahonghu]

NX

[天乐]

来学习了

[zishan169]

看不懂。。。汗。。。。

[WizardOz]

主要是考虑了一些宽字符的情况，所以这么复杂。
我没看明白，也没怎么细看……
这些东西，除非用到，否则没必要研究吧，因为并不是多巧妙，只是问题本身很复杂。

[codiyer]

高人

[pur_e]

mark

[mengde007]

纯粹路过；

[amossavez]

都是强人呀！

[lzx258]

学习。。。。。。。。

[delphiwcdj]

good

[ld6886]

如果要看懂这样经过优化的代码，就一定要对CPU的硬件结构有一定的了解，纯从软件的角度确实会觉得复杂了。

[pcboyxhy]

挨个判断字符是否为0，遇到0则退出，代码很简洁，也不算性能低。只是有点不足，在字长是4字节或者8字节的计算机上，每次只
读取一个字节，有些浪费计算机的能力，如果每次都读取4字节或者8字节，总的读取次数就大大减少，在读取4字节或者8字节的时
候，如果地址不在边界上，机器就要分两次才能读取完成，这样性能将会降低，弱化优化效果，所以前几个字符必须单独处理，然后
从字长 边界地址开始，每次读取4字节或者8字节。

新的方式：

* 开头的几字节单独处理
* 中间部分4字节或者8字节处理
* 最后几字节单独处理

看上去很好，但是还有一个问题，4字节或者8字节读取的时候，如何保证有全0的字节存在，因为0是用来表示字符串的结尾的。
判断连 续的几个字节中是否存在全0的字节，成了优化的关键。我们不能一个字节一个字节判断，因为优化的思想就是一次读取
多个字节，减少 总的读取次数，单独判断每一个字节的话，就失去优化的效果了。

怎么办呢，当然首先考虑位运算了。

* 一个纯0的字节有什么特点? 很明显，每一位都是0，按位取反后每一位都是1。
* 一个全0的字节还有什么特点? 这个字节减1，必然要从更高字节借1，借1后，该字节的最高位必然是1。

似乎有些眉目了，以4字节整数n为例，我们只要把每个字节分别减去1，如果有纯0的字节存在，必然会有借位，借位之后会在
字节最高 位留下一个1。只要判断每个字节的最高位是否存在1就可以了，然而，这里还有一个问题，就是这个4字节整数里，
某些字节本来最高 位可能就含有1，所以必须排除掉这些字节。

解决方案：

* 将n的每一个字节分别减1，并取出最高位，得到x，如果存在借位，该字节最高位就是1
* 将n的每一个字节按位取反并取出最高位，得到y，y中某字节最高位为1，表示它在n里是0
* 将x和y按位与运算，若不等于0，说明n至少有1字节原本最高位不是1，后来变成1了，就是借位

若n中存在全0字节，则 x&y 一定不为0，因为借位的那个字节最高位会被置为1
若n中不存在全0字节，则不会产生借位，x&y 等于0。
x&y == (n-0x01010101) & ~n & 0x80808080

glibc中strcat的实现，基于以上结论，就不难理解了。glibc还考虑了字长是8字节的情况。

[pcboyxhy]

原创 strlen 的高效实现 收藏

处理字符串的时候，经常需要获得字符串的长度，C标准库提供了strlen这个函数，实现一个普通的版本并不
困难，大致上跟下面的代码类似。

view plaincopy to clipboardprint?

1. unsigned int strlen(const char *s)
2. {
3. char *e = s;
4. while (*e)
5. e++;
6. return (e-s);
7. }

unsigned int strlen(const char *s) { char *e = s; while (*e) e++; return (e-s); }

挨个判断字符是否为0，遇到0则退出，代码很简洁，也不算性能低。只是有点不足，在字长是4字节或者8字节
的 计算机上，每次只读取一个字节，有些浪费计算机的能力，如果每次都读取4字节或者8字节，总的读取次数
就大大减少，在读取4字节或者8字节的时候，如果地址不在边界上，机器就要分两次才能读取完成，这样性能
将会降低，弱化优化效果，所以前几个字符必须单独处理，然后从字长 边界地址开始，每次读取4字节或者8字
节。

新的方式：

* 开头的几字节单独处理
* 中间部分4字节或者8字节处理
* 最后几字节单独处理

看上去很好，但是还有一个问题，4字节或者8字节读取的时候，如何保证有全0的字节存在，因为0是用来表示
字符串的结尾的。判断连 续的几个字节中是否存在全0的字节，成了优化的关键。我们不能一个字节一个字节判
断，因为优化的思想就是一次读取多个字节，减少 总的读取次数，单独判断每一个字节的话，就失去优化的效
果了。

怎么办呢，当然首先考虑位运算了。

* 一个纯0的字节有什么特点? 很明显，每一位都是0，按位取反后每一位都是1。
* 一个全0的字节还有什么特点? 这个字节减1，必然要从更高字节借1，借1后，该字节的最高位必然是1。

似乎有些眉目了，以4字节整数n为例，我们只要把每个字节分别减去1，如果有纯0的字节存在，必然会有借位，
借位之后会在字节最高 位留下一个1。只要判断每个字节的最高位是否存在1就可以了，然而，这里还有一个问
题，就是这个4字节整数里，某些字节本来最高 位可能就含有1，所以必须排除掉这些字节。

解决方案：

* 将n的每一个字节分别减1，并取出最高位，得到x，如果存在借位，该字节最高位就是1
* 将n的每一个字节按位取反并取出最高位，得到y，y中某字节最高位为1，表示它在n里是0
* 将x和y按位与运算，若不等于0，说明n至少有1字节原本最高位不是1，后来变成1了，就是借位

若n中存在全0字节，则 x&y 一定不为0，因为借位的那个字节最高位会被置为1
若n中不存在全0字节，则不会产生借位，x&y 等于0。
x&y == (n-0x01010101) & ~n & 0x80808080