/***
*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的字节，成了优化的关键。我们不能一个字节一个字节判
断，因为优化的思想就是一次读取多个字节，减少 总的读取次数，单独判断每一个字节的话，就失去优化的效
果了。
怎么办呢，当然首先考虑位运算了。
* 一个纯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
参考http://www.cppblog.com/ant/archive/2007/10/12/32886.aspx
