strlen源码，远没有想象中的那么简单、、、、

转载

mb5fd86a050ef28 2012-04-12 12:19:00

文章标签 位取反 ide 位运算 hive 解决方案 文章分类 后端开发

/*** *strlen - return the length of a null-terminated string * *Purpose: *       Finds the length in bytes of the given string, not including *       the final null character. * *Entry: *       const char * str - string whose length is to be computed * *Exit: *       length of the string "str", exclusive of the final null byte * *Exceptions: * *******************************************************************************/  size_t __cdecl strlen (         const char * str         ) {         const char *eos = str;          while( *eos++ ) ;          return( eos - str - 1 ); }

01 size_t strlen(str)const char *str; 02 { 03   const char *char_ptr; 04   const unsigned long int *longword_ptr; 05   unsigned long int longword, himagic, lomagic; 06    07   /* Handle the first few 08   characters by reading one character at a time. Do this until CHAR_PTR is 09   aligned on a longword boundary. */ 10   for (char_ptr = str; ((unsigned long int)char_ptr &(sizeof(longword) - 1)) != 11     0; ++char_ptr) 12     if (*char_ptr == '\0') 13       return char_ptr - str; 14        15   /* All these elucidatory comments refer to 4-byte longwords, but the theory 16   applies equally well to 8-byte longwords. */ 17   longword_ptr = (unsigned long int*)char_ptr; 18    19   /* Bits 31, 24, 16, and 8 of  this  number are  zero. Call  these bits the "holes."  20   Note that there is a hole just to the left of each 21   byte, with an extra at the end: bits: 01111110 11111110 11111110 11111111 22   bytes: AAAAAAAA BBBBBBBB CCCCCCCC DDDDDDDD The 1-bits make sure that 23   carries propagate to the next 0-bit. The 0-bits provide holes for carries 24   to fall into. */ 25   himagic = 0x80808080L; 26   lomagic = 0x01010101L; 27   if (sizeof(longword) > 4) 28   { 29      /* 64-bit version of the magic. */ /* Do the shift in two steps to avoid a 30     warning if long has 32 bits. 31      */ 32     himagic = ((himagic << 16) << 16) | himagic; 33     lomagic = ((lomagic << 16) << 16) | lomagic; 34   } 35   if (sizeof(longword) > 8) 36     abort(); 37   /* Instead of the traditional loop which tests each character, we will test 38   a longword at a time. The tricky part is testing if *any of the four* 39   bytes in the longword in question are zero. */ 40   for (;;) 41   { 42     longword =  *longword_ptr++; 43     if (((longword - lomagic) &~longword &himagic) != 0) 44     { 45       /* Which of the bytes was the zero? If none of them were, it was a 46       misfire; continue the search. 47        */ 48       const char *cp = (const char*)(longword_ptr - 1); 49       if (cp[0] == 0) 50         return cp - str; 51       if (cp[1] == 0) 52         return cp - str + 1; 53       if (cp[2] == 0) 54         return cp - str + 2; 55       if (cp[3] == 0) 56         return cp - str + 3; 57       if (sizeof(longword) > 4) 58       { 59         if (cp[4] == 0) 60           return cp - str + 4; 61         if (cp[5] == 0) 62           return cp - str + 5; 63         if (cp[6] == 0) 64           return cp - str + 6; 65         if (cp[7] == 0) 66           return cp - str + 7; 67       } 68     } 69   } 70 }

　　挨个判断字符是否为0，遇到0则退出，代码很简洁，也不算性能低。只是有点不足，在字长是4字节或者8字节

的计算机上，每次只读取一个字节，有些浪费计算机的能力，如果每次都读取4字节或者8字节，总的读取次数

就大大减少，在读取4字节或者8字节的时候，如果地址不在边界上，机器就要分两次才能读取完成，这样性能

将会降低，弱化优化效果，所以前几个字符必须单独处理，然后从字长边界地址开始，每次读取4字节或者8字

节。

新的方式：

* 开头的几字节单独处理

* 中间部分4字节或者8字节处理

* 最后几字节单独处理

看上去很好，但是还有一个问题，4字节或者8字节读取的时候，如何保证有全0的字节存在，因为0是用来表示

字符串的结尾的。判断连续的几个字节中是否存在全0的字节，成了优化的关键。我们不能一个字节一个字节判

断，因为优化的思想就是一次读取多个字节，减少总的读取次数，单独判断每一个字节的话，就失去优化的效