去掉字符串左右两边多余的空格 .

http://blog.csdn.net/gengoo/article/details/2992107

传入字符串string类型, 去掉右边多的空格

1. /**********************************************************************
2. *                                                                     *
3. *   功能: 去掉字符串右边的空格                                        *
4. *   Data: 2008-07-10                                                  *
5. *   author:   xgq                                                     *
6. *                                                                     *
7. **********************************************************************/
8. void TrimRightSpace(string &pString)
9. {
10.     int     strLength = 0;
11.     
12.     if (pString.empty())
13.     {
14.         return;
15.     }
16.     
17.     strLength = pString.size();
18.     
19.     for (int i=strLength-1; i>=0; --i)
20.     {
21.         if ( !isspace(pString[i]))
22.         {
23.             pString = pString.substr(0, i+1);
24.             break;
25.         }
26.     }
28.     return ;
29. }

传入char *指针型字符串, 去掉右边的空格

1. /**********************************************************************
2. *                                                                                                                                         *
3. *   功能: 去掉字符串左边的空格                                                                                    *
4. *   Data: 2008-07-10                                                                                                          *
5. *   author:  xgq                                                                                                                    *
6. *                                                                                                                                          *
7. **********************************************************************/
8. void TrimRightSpace( char* pString )
9. {
10.     int      iStringLen;
11.     int      iCurPos;
12.     
13.     if ( pString == NULL )
14.         return;
15.     
16.     iStringLen= strlen( pString );
17.     
18.     for ( iCurPos= iStringLen-1; iCurPos>=0; iCurPos-- )
19.     {
20.         if ( isspace( pString[ iCurPos ] ) )
21.         {
22.             pString[ iCurPos ]= '/0';
23.             continue;
24.         }
25.         else
26.             break;
27.     }
28. }

传入char *类型的字符串指针, 去掉左边的空格

1. /**********************************************************************
2. *                                                                                                                                         *
3. *   功能: 去掉字符串左边的空格                                                                                    *
4. *   Data: 2008-07-10                                                                                                          *
5. *   author:  xgq                                                                                                                    *
6. *                                                                                                                                          *
7. **********************************************************************/
8. char* TrimLeftSpace(char* sStr)
9. {
10.     if ( !sStr )
11.         return NULL;
12.     
13.     while ( 1 )
14.     {
15.         if ( *sStr == 0 )
16.             return NULL;
17.         
18.         if ( !isspace( *sStr ) )
19.             return sStr;
20.         
21.         sStr++;
22.     }
23.     
24.     return NULL;
25. }

传入string类型的字符串, 去掉左边的空格, 仅在第一个非空格字符前面保留一个空格

1. /**********************************************************************
2. *                                                                                                                                         *
3. *   功能: 去掉字符串左边的空格                                                                                    *
4. *   Data: 2008-07-10                                                                                                          *
5. *   author:  xgq                                                                                                                    *
6. *                                                                                                                                          *
7. **********************************************************************/
8. void  TrimLeftSpace(string &pString)
9. {   
10.     if (pString.empty())
11.     {
12.         return ;
13.     }
14.     
15.     unsigned long i = 0;
16.     while ( i<pString.size() )
17.     {
18.         if ( !isspace( pString.at(i) ) )
19.         {
20.             if (i>1)
21.                 i -= 1;
22.             pString = pString.substr(i, pString.size());
23.             break;
24.         }
25.         
26.         ++i;
27.     }
28.     
29.     return ;
30. }

 

 

二。去掉字符串左右两边的空格

http://blog.chinaunix.net/uid-24919665-id-2783179.html

本文针对实现去除字符串左右空格的功能进行探讨，在牛人代码的基础上进行改进并加以注释。本文参照了cu论坛flw的精华帖，在此表示感谢：

http://bbs.chinaunix.net/viewthread.php?tid=271575&extra=&page=1

源实现如下：

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. 
   
4. /*****************************************************************
   
5.  *函数功能：去除字符串左右两边的空格
   
6. 
   
7.  *传入参数：str:需要处理的字符串
   
8. 
   
9.  *传出参数：无（由于传入的是指针，形参指向元素的改变将影响实参）
   
10. 
    
11.  *返回值：无
    
12. 
    
13.  *******************************************************************/
    
14. void trim( char *str )
    
15. {
    
16.         char *copied, *tail = NULL;
    
17.     
    
18.     /*判空*/
    
19.         if ( str == NULL )
    
20.                 return;
    
21.     
    
22.     /*去除字符串左边空格，并找到字符串右边的第一个空格*/
    
23.         for( copied = str; *str; str++ )
    
24.         {
    
25.             /*当前字符不为空格时，将当前字符拷贝到新的字符串中，并更新tail指针指向的空间
    
26.              为新字符串的尾部*/
    
27.                 if ( *str != ' ' && *str != '\t' )
    
28.                 {
    
29.                         *copied++ = *str;
    
30.                          tail = copied;
    
31.                 }
    
32.                 else
    
33.                 {    
    
34.                      /*当tail不为空时，将当前字符拷贝到新的字符串中：由于tail初值为NULL，
    
35.                      找到第一个非空格字符时才会将其值更新，所以能够保证去除字符串左边
    
36.                      的空格，而保留中间和右边的空格*/
    
37.                          if ( tail )
    
38.                                  *copied++ = *str;
    
39.                 }
    
40.         }
    
41.     
    
42.     /*去除字符串右边的空格：如果tail非空，则将tail赋'\0'（将其后的字符截断）;
    
43.      否则将字符串清空（即传入字符串全为空格）*/
    
44.         if ( tail )
    
45.              *tail = 0;
    
46.         else
    
47.              *copied = 0;
    
48. 
    
49.         return;
    
50. }
    
51. 
    
52. int main(void)
    
53. {
    
54.     char string[100] = " abcd ef gh -- ijk ";
    
55.     trim(string);
    
56.     printf(string);
    
57.     printf("\n");
    
58. 
    
59.     return 0;
    
60. }

由于上面的代码需要移动字符串中元素，可能效率较慢，本人的思路是将第一个非空格字符处做一

标记（将一局部指针指向此处），找到右边第一个空格并将其赋值为字符串结束符。最后返回局部指针。程序实现如下：

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. /*************************************************
   
4.  *函数功能：去除字符串左右两边的空格
   
5. 
   
6.  *传入参数：str:需要处理的字符串
   
7. 
   
8.  *传出参数：无
   
9. 
   
10.  *返回值：处理后的字符串
    
11. 
    
12.  ************************************************/
    
13. char * trim( char *str )
    
14. {
    
15.     char *head, *tail = NULL;
    
16.     
    
17.     if ( str == NULL )
    
18.         return str;
    
19.     
    
20.     for( head = str; *str; str++ )
    
21.     {
    
22.         if ( *str != ' ' && *str != '\t' )
    
23.         {            
    
24.             if (tail == NULL)
    
25.             {
    
26.                 head = str;//tail为NULL时，此处为第一个非空格字符，将此位置保存下来
    
27.             }
    
28.             tail = str+1;//更新tail指针的指向为非空格字符的下一个位置
    
29.         }        
    
30.     }
    
31.     /*由于tail始终指向非空格字符的下一个位置，当循环退出时，tail指向右边第一个空格*/
    
32.     if ( tail )
    
33.         *tail = 0;
    
34.     else
    
35.         *head = 0;
    
36.     
    
37.     return head;
    
38. }
    
39. 
    
40. int main(void)
    
41. {
    
42.     char string[100] = " abcd ef gh -- ijk ";
    
43.     char * p = trim(string);
    
44.     printf(p);
    
45.     printf("\n");
    
46. 
    
47.     return 0;
    
48. }

除了上面这种思路，还有一种思路是“从前往后 数掉前面的空格”，再“从后往前 数掉后面的空格”，等“数”出了实际有效的第一个字符和最后一个字符之后，再用 strcpy 或者 memcpy 拷贝过去。

本人思路：

char *trim(char *str)

{

int i = 0;

int j = 0;

int len = strlen(str);

assert(str !=NULL && len>0);

for (i = 0; i<len; i++)

{

if (*(str+i) != ' ' && *(str+i) != '\t')

{

break;

}

}

for (j = len-1; j>=0; j--)

{

if (*(str+j) !=' ' && *(str+j) != '\t')

{

break;

}

}

*(str+j+1) = '\0';

return str+i;//等价于return memmove(str,str+i,j-i+2);此处其实亦可以用memcpy（参考其实现）

}

事实上，Trim 从算法上来讲，也就这两个思路，大多数人采用的是后面的这个思路，好像依赖于 strlen、memcpy 等库函数的效率后，反而要更快些。而上面的那个思路，似乎没有多少人去想，结果就吃亏在“效率”问题上了。

关于第二种思路在此不再继续探讨，如果有兴趣可以参照文章：

http://bbs.chinaunix.net/thread-277036-1-1.html

上面这边文章中的不足是，最后的memcpy函数源和目的地址存在重叠情况，结果依赖于实现，应该使用memmove。