优化版flw的超强版 Trim ，欢迎高手拍砖

snowboy9859

本人不才，站在牛人的肩膀上学习写代码，其中代码引用了flw的思路，在此表示感谢。下面这段代码可能存在哪些漏洞，欢迎专家们点评
由于flw的代码需要移动字符串中元素，可能效率较慢，本人的思路是将第一个非空格字符处做一
标记（将一局部指针指向此处），找到右边第一个空格并将其赋值为字符串结束符。最后返回局部指针。程序实现如下：

1. /*************************************************
   
2. *函数功能：去除字符串左右两边的空格
   
3. 
   
4. *传入参数：str:需要处理的字符串
   
5. 
   
6. *传出参数：无
   
7. 
   
8. *返回值：处理后的字符串
   
9. 
   
10. ************************************************/
    
11. char * trim( char *str )
    
12. {
    
13.     char *head, *tail = NULL;
    
14.    
    
15.     if ( str == NULL )
    
16.         return str;
    
17.    
    
18.     for( head = str; *str; str++ )
    
19.     {
    
20.         if ( *str != ' ' && *str != '\t' )
    
21.         {            
    
22.             if (tail == NULL)
    
23.             {
    
24.                 head = str;//tail为NULL时，此处为第一个非空格字符，将此位置保存下来
    
25.             }
    
26.             tail = str+1;//更新tail指针的指向为非空格字符的下一个位置
    
27.         }        
    
28.     }
    
29.     /*由于tail始终指向非空格字符的下一个位置，当循环退出时，tail指向右边第一个空格*/
    
30.     if ( tail )
    
31.         *tail = 0;
    
32.     else
    
33.         *head = 0;
    
34.    
    
35.     return head;
    
36. }

复制代码

AD8018

那是flw当年情窦初开时的作品

suosuopuo

有一个小问题，因为没有移动数据，所以存放原字符串的数组开头还是保存着空白符，相反结尾的空白已经截掉，直接使用原数组的时候也不会得到尾部空白。虽然返回了第一个非空白符的地址，但这样一来，就有必要把返回值保存起来，还要记住下面的程序不能再用原来那个数组名来表示字符串了。这样的代码会有点混乱。。。还是移动数据的设计比较合理

fender0107401

那是flw当年情窦初开时的作品
AD8018 发表于 2011-10-07 21:18

Missex

有一个小问题，因为没有移动数据，所以存放原字符串的数组开头还是保存着空白符，相反结尾的空白已经截掉， ...
suosuopuo 发表于 2011-10-08 00:36

    不同的地方不同的用法， 当然，都遍历一遍了， 顺便移动一下也没什么

snowboy9859

回复 3# suosuopuo


    这样的代码会有点混乱。。。还是移动数据的设计比较合理？难道移动数据就不会破坏原来字符数组了么？

suosuopuo

回复 6# snowboy9859


    不是不会破坏，是保持各个地方一致，想想用户的使用体验啊。。。

suosuopuo

回复 6# snowboy9859


    你见过把原数据改掉一半的标准库函数吗？要么就加const限制改动原数据，要么就确保各个地方能得到一致的数据。。。

fallening

我觉得有两个地方可以优化：
1） 查找前边一个空格的时候，可以参照 glibc 的 strlen 实现优化：

1. size_t
   
2. strlen (str)
   
3.      const char *str;
   
4. {
   
5.   const char *char_ptr;
   
6.   const unsigned long int *longword_ptr;
   
7.   unsigned long int longword, magic_bits, himagic, lomagic;
   
8. 
   
9.   for (char_ptr = str; ((unsigned long int) char_ptr
   
10.                         & (sizeof (longword) - 1)) != 0;
    
11.        ++char_ptr)
    
12.     if (*char_ptr == '\0')
    
13.       return char_ptr - str;
    
14. 
    
15.   longword_ptr = (unsigned long int *) char_ptr;
    
16. 
    
17.   magic_bits = 0x7efefeffL;
    
18.   himagic = 0x80808080L;
    
19.   lomagic = 0x01010101L;
    
20.   if (sizeof (longword) > 4)
    
21.     {
    
22.       magic_bits = ((0x7efefefeL << 16) << 16) | 0xfefefeffL;
    
23.       himagic = ((himagic << 16) << 16) | himagic;
    
24.       lomagic = ((lomagic << 16) << 16) | lomagic;
    
25.     }
    
26.   if (sizeof (longword) > 8)
    
27.     abort ();
    
28. 
    
29.   for (;;)
    
30.     {
    
31. 
    
32.       longword = *longword_ptr++;
    
33. 
    
34.       if (
    
35. #if 0
    
36.           (((longword + magic_bits)
    
37.             ^ ~longword)
    
38.            & ~magic_bits)
    
39. #else
    
40.           ((longword - lomagic) & himagic)
    
41. #endif
    
42.           != 0)
    
43.         {
    
44. 
    
45.           const char *cp = (const char *) (longword_ptr - 1);
    
46. 
    
47.           if (cp[0] == 0)
    
48.             return cp - str;
    
49.           if (cp[1] == 0)
    
50.             return cp - str + 1;
    
51.           if (cp[2] == 0)
    
52.             return cp - str + 2;
    
53.           if (cp[3] == 0)
    
54.             return cp - str + 3;
    
55.           if (sizeof (longword) > 4)
    
56.             {
    
57.               if (cp[4] == 0)
    
58.                 return cp - str + 4;
    
59.               if (cp[5] == 0)
    
60.                 return cp - str + 5;
    
61.               if (cp[6] == 0)
    
62.                 return cp - str + 6;
    
63.               if (cp[7] == 0)
    
64.                 return cp - str + 7;
    
65.             }
    
66.         }
    
67.     }
    
68. }

复制代码

2） 查找后边一个空格的时候，可以根据字符串的长度，决定 tail 是从前往后找还是从后往前找。当然这个阈值需要统计大量样本找出经验值来，而且可能在不同的机器上存在差别。

btdm123

过早优化是万恶之源