strlen 实现

 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都是一次判断一个字符直到发现""为止，这是非常低效的。比较高效的实现如下(在这里WORD表示计算机中的一个字，不是WORD类型)：
(1) 一次判断一个字符直到内存对齐，如果在内存对齐之前就遇到""则直接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 == "" )
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 == "")
        return char_ptr - str;
}

上面的代码实现了数据对齐，如果在对齐之前就遇到""则可以直接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;
strlen.c linux标准实现
size_t strlen (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 == "")       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;     } }     } }

从这段代码开头作者的注释我们大致可以了解到该strlen实现的原理：就是通过每次测试四个字节来代替传统实现中每次测试一个字节的方法。知道这个原理了，那么还需要解决两个难题：
1) C标准库要求有很好的移植性，在绝大部分系统体系结构下都应该能正确运行。那么每次拿出4个字节比较(unsigned long int)，就需要考虑内存对齐问题，传入的字符串的首字符地址可不一定在4对齐的地址上；
2) 如何对四个字节进行测试，找出其中某个字节为全0，这是个技巧问题。

12～21行的代码解决的就是第一个问题：
      for (char_ptr = str; ((unsigned long int) char_ptr
             & (sizeof (longword) – 1)) != 0;
             ++char_ptr)
                if (*char_ptr == "")
                        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;
作者通过一个for-loop找到传入字符串中第一个地址对齐到4的字符的地址，由于该地址已经对齐到4，所以最后一行那个强制转型是安全的。虽然可以通过圆整算式直接得到该对齐地址，但是考虑到这个区间可能存在的""，一个字符一个字符比对也是不可避免的。在很多严格对齐的架构上(比如SUN的SPARC平台)，编译器一般会将字符串地址在编译器就放到对齐的地址上，这样一来，实际执行strlen时for-loop很少能执行一步。

第二个问题作者则是通过一个"带前提"的技巧来解决的。作者设定了两个掩码变量：
 himagic = 0x80808080L;
 lomagic = 0x01010101L;
并通过一个conditional expression完成了对四字节中全0字节的检测：((longword – lomagic) & himagic) != 0
我们将himagic和lomagic按bit展开：
himagic   1000 0000 1000 0000 1000 0000 1000 0000
lomagic   0000 0001 0000 0001 0000 0001 0000 0001

对于这样的代码，似乎没有什么理论可以遵循，需要在实践中去理解。起初我构造了一个不含全0字节的longword，比如：
longword  1000 0001 1000 0001 1000 0001 1000 0001，然后按照那个条件表达式计算后，居然也满足!=0的条件，是不是作者的逻辑有问题呢？后来转念一想，这种逻辑是有“前提条件”的。回顾一下strlen是做什么的，其输入参数是任意的么？当然不是。输入的字符串中每个字符的值都在[0, 127]的ascii码范围内，也就是说每个字节最高位的bit都是0，这样longword就应该是如下这个样子了：
longword  0xxx xxxx 0xxx xxxx 0xxx xxxx 0xxx xxxx

基于这样的前提我们考虑两种情况：
当longword中没有全0字节时，比如：
longword 0000 0001 0000 0001 0000 0001 0000 0001
这样在做完计算后，值为0，不满足条件。

当longword中有全零字节时，比如：
longword 0000 0000 0000 0001 0000 0001 0000 0001
这样在做完计算后，最高字节最高bit的值肯定为1，满足!=0条件，全0字节被检测出来。也就是说一旦有全0字节，在减去lomagic时势必会产生借位，全0的那个字节在减去lomagic后最高位bit肯定由0变1，这样与himagic一与，肯定不为0，就是这么检测出来的。

这一方法在64位平台依然适用，上面的代码摘要中省略了对64bit平台的特殊处理，为的是使代码逻辑更清晰，更易读。

4. 另一种实现
 1 size_t strlen_d(const char *str) {
 2 
 3     const char *char_ptr;
 4     const ulong *longword_ptr;
 5     register ulong longword, himagic, lomagic;
 6 
 7     for (char_ptr = str; ((ulong)char_ptr 
 8         & (sizeof(ulong) - 1)) != 0;
 9         ++char_ptr) {
10         if (*char_ptr == "")
11             return char_ptr - str;
12     }
13 
14     longword_ptr = (ulong*)char_ptr;
15 
16     himagic = 0x80808080L;
17     lomagic = 0x01010101L;
18 
19     while (1) {
20 
21         longword = *longword_ptr++;
22 
23         if (((longword - lomagic) & himagic) != 0) {
24 
25             const char *cp = (const char*)(longword_ptr - 1);
26             
27             if (cp[0] == 0)
28                 return cp - str;
29             if (cp[1] == 0)
30                 return cp - str + 1;
31             if (cp[2] == 0)
32                 return cp - str + 2;
33             if (cp[3] == 0)
34                 return cp - str + 3;
35         }
36     }
37 } 上面的代码与strlen_c基本一样，不同的是：
magic_bits换成了himagic和lomagic
himagic = 0x80808080L;
lomagic = 0x01010101L; 以及 if语句变得比较简单了
if (((longword - lomagic) & himagic) != 0)
if语句中的计算可以分为如下2步：
(1) longword - lomagic
himagic和lomagic的二进制表示如下：
                b3      b2       b1       b0
            31------------------------------->0
  himagic:  10000000 10000000 10000000 10000000
  lomagic:  00000001 00000001 00000001 00000001
在这种方法中假设所有字符都是ASCII标准字符，其值在0-127之间，因此longword总是如下形式：
                b3      b2       b1       b0
            31------------------------------->0
  longword: 0XXXXXXX 0XXXXXXX 0XXXXXXX 0XXXXXXX

检测0字节：
如果longword 中有一个字节的所有bit都为0，则进行减法后，这个字节的最高位一定会从0变为1；相反，如果longword中所有字节都不为0，则每个字节中至少有1位为1，进行减法后这个字节的最高位依然为0。

 (2)  & himagic
这一步取出每个字节最高位的1，如果有任意字节最高位为1则说明longword中有为0的字节。

根据上面的描述，如果longword中有为0的字节，则if中的表达式结果为非0，否则为0。