没有想的到，只有想不到，strlen源码剖析

学习高效编程的有效途径之一就是阅读高手写的源代码，作为底层的函数库，实现必然高效。

strlen的函数原形如下：
size_t strlen(const char *str);

strlen返回str中字符的个数，其中str为一个以'\0'结尾的字符串(a null-terminated string)。

1. 简单实现
如果不管效率，最简单的实现只需要4行代码：

1 size_t strlen_a(const char * str) {

2    size_t length = 0 ;

3    while (*str++ )

4　　 　　　　++ length;

5    return length;

6 }

也许可以稍加改进如下：

1 size_t strlen_b(const char * str) {

2    const char *cp = str;

3    while (*cp++ )

4         ;

5    return (cp - str - 1 );

6 }

 

2. 高效实现
很显然，标准库的实现肯定不会如此简单，上面的strlen_a以及strlen_b都是一次判断一个字符直到发现'\0'为止，这是非常低效的。比较高效的实现如下(在这里WORD表示计算机中的一个字，不是WORD类型)：
(1) 一次判断一个字符直到内存对齐，如果在内存对齐之前就遇到'\0'则直接return，否则到(2)；
(2) 一次读入并判断一个WORD，如果此WORD中没有为0的字节，则继续下一个WORD，否则到(3)；
(3) 到这里则说明WORD中至少有一个字节为0，剩下的就是找出第一个为0的字节的位置然后return。

NOTE：
数据对齐(data alignment)，是指数据所在的内存地址必须是该数据长度的整数倍，这样CPU的存取速度最快。比如在32位的计算机中，一个WORD为4 byte，则WORD数据的起始地址能被4整除的时候CPU的存取效率比较高。CPU的优化规则大概如下：对于n字节(n = 2,4,8...)的元素，它的首地址能被n整除才能获得最好的性能。

为了便于下面的讨论，这里假设所用的计算机为32位，即一个WORD为4个字节。下面给出在32位计算机上的C语言实现(假设unsigned long为4个字节)：

1 typedef unsigned long ulong;
2
3 size_t strlen_c(const char * str) {
4
5    const char * char_ptr;
6    const ulong * longword_ptr;
7    register ulong longword, magic_bits;
8
9    for (char_ptr = str; ((ulong)char_ptr
10          & (sizeof(ulong) - 1)) != 0 ;
11          ++ char_ptr) {
12     if (*char_ptr == '\0' )
13     return char_ptr - str;
14   }
15
16   longword_ptr = (ulong* )char_ptr;
17
18   magic_bits = 0x7efefeffL ;
19
20   while (1 ) {
21
22    longword = *longword_ptr++ ;
23
24    if ((((longword + magic_bits) ^ ~longword) & ~magic_bits) != 0 ) {
25
26       const char *cp = (const char*)(longword_ptr - 1 );
27
28       if (cp[0] == 0 )
29          return cp - str;
30       if (cp[1] == 0 )
31          return cp - str + 1 ;
32       if (cp[2] == 0 )
33          return cp - str + 2 ;
34       if (cp[3] == 0 )
35          return cp - str + 3 ;
36     }
37   }
38 }

3. 源码剖析
上面给出的C语言实现虽然不算特别复杂，但也值得花点时间来弄清楚，先看9-14行：

for (char_ptr = str; ((ulong)char_ptr & (sizeof(ulong) - 1)) != 0; ++char_ptr) {

   if (*char_ptr == '\0')

      return char_ptr - str;

}

上面的代码实现了数据对齐，如果在对齐之前就遇到'\0'则可以直接return char_ptr - str;

第16行将longword_ptr指向数据对齐后的首地址

longword_ptr = (ulong*)char_ptr;

第18行给magic_bits赋值(在后面会解释这个值的意义)

magic_bits = 0x7efefeffL;

第22行读入一个WORD到longword并将longword_ptr指向下一个WORD

longword = *longword_ptr++;

第24行的if语句是整个算法的核心，该语句判断22行读入的WORD中是否有为0的字节

if ((((longword + magic_bits) ^ ~longword) & ~magic_bits) != 0)

if语句中的计算可以分为如下3步：
(1) longword + magic_bits
其中magic_bits的二进制表示如下：

                b3      b2       b1       b0

            31------------------------------->0

magic_bits: 01111110 11111110 11111110 11111111

magic_bits中的31,24,16,8这些bits都为0，我们把这几个bits称为holes，注意在每个byte的左边都有一个hole。

检测0字节：
如果longword 中有一个字节的所有bit都为0，则进行加法后，从这个字节的右边的字节传递来的进位都会落到这个字节的最低位所在的hole上，而从这个字节的最高位则永远不会产生向左边字节的hole的进位。则这个字节左边的hole在进行加法后不会改变，由此可以检测出0字节；相反，如果longword中所有字节都不为0，则每个字节中至少有1位为1，进行加法后所有的hole都会被改变。

为了便于理解，请看下面的例子：

              b3      b2      b1       b0

          31------------------------------->0

longword: XXXXXXXX XXXXXXXX 00000000 XXXXXXXX

+ magic_bits: 01111110 11111110 11111110 11111111

上面longword中的b1为0，X可能为0也可能为1。因为b1的所有bit都为0，而从b0传递过来的进位只可能是0或1，很显然b1永远也不会产生进位，所以加法后longword的第16 bit这个hole不会变。

(2) ^ ~longword
这一步取出加法后longword中所有未改变的bit。

(3) & ~magic_bits
最后取出longword中未改变的hole，如果有任何hole未改变则说明longword中有为0的字节。

根据上面的描述，如果longword中有为0的字节，则if中的表达式结果为非0，否则为0。
NOTE：
如果b3为10000000，则进行加法后第31 bit这个hole不会变，这说明我们无法检测出b3为10000000的所有WORD。值得庆幸的是用于strlen的字符串都是ASCII标准字符，其值在0-127之间，这意味着每一个字节的第一个bit都为0。因此上面的算法是安全的。

一旦检测出longword中有为0的字节，后面的代码只需要找到第一个为0的字节并返回相应的长度就OK：

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;

原帖地址：http://www.cppblog.com/ant/archive/2007/10/12/32886.html