blocks|key|1531454|text|如果可以修改字符串：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1531455|//+Note:+This+function+returns+a+pointer+to+a+substring+of+the+original+string.
//+If+the+given+string+was+allocated+dynamically,+the+caller+must+not+overwrite
//+that+pointer+with+the+returned+value,+since+the+original+pointer+must+be
//+deallocated+using+the+same+allocator+with+which+it+was+allocated.++The+return
//+value+must+NOT+be+deallocated+using+free()+etc.
char+*trimwhitespace(char+*str)
{
++char+*end;

++//+Trim+leading+space
++while(isspace((unsigned+char)*str))+str%2B%2B;

++if(*str+==+0)++//+All+spaces?
++++return+str;

++//+Trim+trailing+space
++end+=+str+%2B+strlen(str)+-+1;
++while(end+>+str+&&+isspace((unsigned+char)*end))+end--;

++//+Write+new+null+terminator+character
++end[1]+=+'\0';

++return+str;
}|code-block|syntax|javascript|1531456|如果你不能修改字符串，那么你可以使用基本上相同的方法：|1531457|//+Stores+the+trimmed+input+string+into+the+given+output+buffer,+which+must+be
//+large+enough+to+store+the+result.++If+it+is+too+small,+the+output+is
//+truncated.
size_t+trimwhitespace(char+*out,+size_t+len,+const+char+*str)
{
++if(len+==+0)
++++return+0;

++const+char+*end;
++size_t+out_size;

++//+Trim+leading+space
++while(isspace((unsigned+char)*str))+str%2B%2B;

++if(*str+==+0)++//+All+spaces?
++{
++++*out+=+0;
++++return+1;
++}

++//+Trim+trailing+space
++end+=+str+%2B+strlen(str)+-+1;
++while(end+>+str+&&+isspace((unsigned+char)*end))+end--;
++end%2B%2B;

++//+Set+output+size+to+minimum+of+trimmed+string+length+and+buffer+size+minus+1
++out_size+=+(end+-+str)+<+len-1+?+(end+-+str)+:+len-1;

++//+Copy+trimmed+string+and+add+null+terminator
++memcpy(out,+str,+out_size);
++out[out_size]+=+0;

++return+out_size;
}|1531458|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

If you can modify the string:

<pre><code>// Note: This function returns a pointer to a substring of the original string.
// If the given string was allocated dynamically, the caller must not overwrite
// that pointer with the returned value, since the original pointer must be
// deallocated using the same allocator with which it was allocated. The return
// value must NOT be deallocated using free() etc.
char *trimwhitespace(char *str)
{
 char *end;

 // Trim leading space
 while(isspace((unsigned char)*str)) str++;

 if(*str == 0) // All spaces?
 return str;

 // Trim trailing space
 end = str + strlen(str) - 1;
 while(end &gt; str &amp;&amp; isspace((unsigned char)*end)) end--;

 // Write new null terminator character
 end[1] = '\0';

 return str;
}
</code></pre>

If you can't modify the string, then you can use basically the same method:

<pre><code>// Stores the trimmed input string into the given output buffer, which must be
// large enough to store the result. If it is too small, the output is
// truncated.
size_t trimwhitespace(char *out, size_t len, const char *str)
{
 if(len == 0)
 return 0;

 const char *end;
 size_t out_size;

 // Trim leading space
 while(isspace((unsigned char)*str)) str++;

 if(*str == 0) // All spaces?
 {
 *out = 0;
 return 1;
 }

 // Trim trailing space
 end = str + strlen(str) - 1;
 while(end &gt; str &amp;&amp; isspace((unsigned char)*end)) end--;
 end++;

 // Set output size to minimum of trimmed string length and buffer size minus 1
 out_size = (end - str) &lt; len-1 ? (end - str) : len-1;

 // Copy trimmed string and add null terminator
 memcpy(out, str, out_size);
 out[out_size] = 0;

 return out_size;
}
</code></pre>

blocks|key|1531497|text|就我个人而言，我会推出我自己的。您可以使用strtok，但您需要注意这样做(特别是如果您要删除前导字符)，以便您知道什么是内存。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1531498|去掉尾随空格很容易，而且很安全，因为你可以在最后一个空格的顶部加上一个0，从最后一个空格开始倒数。去掉前导空格意味着到处移动东西。如果你想在适当的地方做(可能是明智的)，你可以一直把所有的东西都移回一个字符，直到没有前导空格。或者，为了更有效率，您可以找到第一个非空格字符的索引，然后将所有内容按该数字移位。或者，您可以只使用指向第一个非空格字符的指针(但您需要像处理strtok一样小心)。|1531499|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Personally, I'd roll my own. You can use strtok, but you need to take care with doing so (particularly if you're removing leading characters) that you know what memory is what.

Getting rid of trailing spaces is easy, and pretty safe, as you can just put a 0 in over the top of the last space, counting back from the end. Getting rid of leading spaces means moving things around. If you want to do it in place (probably sensible) you can just keep shifting everything back one character until there's no leading space. Or, to be more efficient, you could find the index of the first non-space character, and shift everything back by that number. Or, you could just use a pointer to the first non-space character (but then you need to be careful in the same way as you do with strtok).

blocks|key|1531535|text|这是一个将字符串移动到缓冲区的第一个位置的函数。您可能想要此行为，以便在动态分配字符串时，仍然可以在trim()返回的同一指针上释放它：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1531536|char+*trim(char+*str)
{
++++size_t+len+=+0;
++++char+*frontp+=+str;
++++char+*endp+=+NULL;

++++if(+str+==+NULL+)+{+return+NULL;+}
++++if(+str[0]+==+'\0'+)+{+return+str;+}

++++len+=+strlen(str);
++++endp+=+str+%2B+len;

++++/*+Move+the+front+and+back+pointers+to+address+the+first+non-whitespace
+++++*+characters+from+each+end.
+++++*/
++++while(+isspace((unsigned+char)+*frontp)+)+{+%2B%2Bfrontp;+}
++++if(+endp+!=+frontp+)
++++{
++++++++while(+isspace((unsigned+char)+*(--endp))+&&+endp+!=+frontp+)+{}
++++}

++++if(+frontp+!=+str+&&+endp+==+frontp+)
++++++++++++*str+=+'\0';
++++else+if(+str+%2B+len+-+1+!=+endp+)
++++++++++++*(endp+%2B+1)+=+'\0';

++++/*+Shift+the+string+so+that+it+starts+at+str+so+that+if+it's+dynamically
+++++*+allocated,+we+can+still+free+it+on+the+returned+pointer.++Note+the+reuse
+++++*+of+endp+to+mean+the+front+of+the+string+buffer+now.
+++++*/
++++endp+=+str;
++++if(+frontp+!=+str+)
++++{
++++++++++++while(+*frontp+)+{+*endp%2B%2B+=+*frontp%2B%2B;+}
++++++++++++*endp+=+'\0';
++++}

++++return+str;
}|code-block|syntax|javascript|1531537|测试正确性：|1531538|#include+<stdio.h>
#include+<string.h>
#include+<ctype.h>

/*+Paste+function+from+above+here.+*/

int+main()
{
++++/*+The+test+prints+the+following:
++++[nothing+to+trim]+->+[nothing+to+trim]
++++[++++trim+the+front]+->+[trim+the+front]
++++[trim+the+back+++++]+->+[trim+the+back]
++++[++++trim+front+and+back+++++]+->+[trim+front+and+back]
++++[+trim+one+char+front+and+back+]+->+[trim+one+char+front+and+back]
++++[+trim+one+char+front]+->+[trim+one+char+front]
++++[trim+one+char+back+]+->+[trim+one+char+back]
++++[+++++++++++++++++++]+->+[]
++++[+]+->+[]
++++[a]+->+[a]
++++[]+->+[]
++++*/

++++char+*sample_strings[]+=
++++{
++++++++++++"nothing+to+trim",
++++++++++++"++++trim+the+front",
++++++++++++"trim+the+back+++++",
++++++++++++"++++trim+front+and+back+++++",
++++++++++++"+trim+one+char+front+and+back+",
++++++++++++"+trim+one+char+front",
++++++++++++"trim+one+char+back+",
++++++++++++"+++++++++++++++++++",
++++++++++++"+",
++++++++++++"a",
++++++++++++"",
++++++++++++NULL
++++};
++++char+test_buffer[64];
++++char+comparison_buffer[64];
++++size_t+index,+compare_pos;

++++for(+index+=+0;+sample_strings[index]+!=+NULL;+%2B%2Bindex+)
++++{
++++++++//+Fill+buffer+with+known+value+to+verify+we+do+not+write+past+the+end+of+the+string.
++++++++memset(+test_buffer,+0xCC,+sizeof(test_buffer)+);
++++++++strcpy(+test_buffer,+sample_strings[index]+);
++++++++memcpy(+comparison_buffer,+test_buffer,+sizeof(comparison_buffer));

++++++++printf("[%25s]+->+[%25s]\n",+sample_strings[index],
+++++++++++++++++++++++++++++++++trim(test_buffer));

++++++++for(+compare_pos+=+strlen(comparison_buffer);
+++++++++++++compare_pos+<+sizeof(comparison_buffer);
+++++++++++++%2B%2Bcompare_pos+)
++++++++{
++++++++++++if(+test_buffer[compare_pos]+!=+comparison_buffer[compare_pos]+)
++++++++++++{
++++++++++++++++printf("Unexpected+change+to+buffer+@+index+%25u:+%2502x+(expected+%2502x)\n",
++++++++++++++++++++compare_pos,+(unsigned+char)+test_buffer[compare_pos],+(unsigned+char)+comparison_buffer[compare_pos]);
++++++++++++}
++++++++}
++++}

++++return+0;
}|1531539|源文件是trim.c。使用“cc+-Wall+trim.c+-o+trim”编译。|1531540|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Here's one that shifts the string into the first position of your buffer. You might want this behavior so that if you dynamically allocated the string, you can still free it on the same pointer that trim() returns:

<pre><code>char *trim(char *str)
{
 size_t len = 0;
 char *frontp = str;
 char *endp = NULL;

 if( str == NULL ) { return NULL; }
 if( str[0] == '\0' ) { return str; }

 len = strlen(str);
 endp = str + len;

 /* Move the front and back pointers to address the first non-whitespace
 * characters from each end.
 */
 while( isspace((unsigned char) *frontp) ) { ++frontp; }
 if( endp != frontp )
 {
 while( isspace((unsigned char) *(--endp)) &amp;&amp; endp != frontp ) {}
 }

 if( frontp != str &amp;&amp; endp == frontp )
 *str = '\0';
 else if( str + len - 1 != endp )
 *(endp + 1) = '\0';

 /* Shift the string so that it starts at str so that if it's dynamically
 * allocated, we can still free it on the returned pointer. Note the reuse
 * of endp to mean the front of the string buffer now.
 */
 endp = str;
 if( frontp != str )
 {
 while( *frontp ) { *endp++ = *frontp++; }
 *endp = '\0';
 }

 return str;
}
</code></pre>

Test for correctness:

<pre><code>#include &lt;stdio.h&gt;
#include &lt;string.h&gt;
#include &lt;ctype.h&gt;

/* Paste function from above here. */

int main()
{
 /* The test prints the following:
 [nothing to trim] -&gt; [nothing to trim]
 [ trim the front] -&gt; [trim the front]
 [trim the back ] -&gt; [trim the back]
 [ trim front and back ] -&gt; [trim front and back]
 [ trim one char front and back ] -&gt; [trim one char front and back]
 [ trim one char front] -&gt; [trim one char front]
 [trim one char back ] -&gt; [trim one char back]
 [ ] -&gt; []
 [ ] -&gt; []
 [a] -&gt; [a]
 [] -&gt; []
 */

 char *sample_strings[] =
 {
 "nothing to trim",
 " trim the front",
 "trim the back ",
 " trim front and back ",
 " trim one char front and back ",
 " trim one char front",
 "trim one char back ",
 " ",
 " ",
 "a",
 "",
 NULL
 };
 char test_buffer[64];
 char comparison_buffer[64];
 size_t index, compare_pos;

 for( index = 0; sample_strings[index] != NULL; ++index )
 {
 // Fill buffer with known value to verify we do not write past the end of the string.
 memset( test_buffer, 0xCC, sizeof(test_buffer) );
 strcpy( test_buffer, sample_strings[index] );
 memcpy( comparison_buffer, test_buffer, sizeof(comparison_buffer));

 printf("[%s] -&gt; [%s]\n", sample_strings[index],
 trim(test_buffer));

 for( compare_pos = strlen(comparison_buffer);
 compare_pos &lt; sizeof(comparison_buffer);
 ++compare_pos )
 {
 if( test_buffer[compare_pos] != comparison_buffer[compare_pos] )
 {
 printf("Unexpected change to buffer @ index %u: %02x (expected %02x)\n",
 compare_pos, (unsigned char) test_buffer[compare_pos], (unsigned char) comparison_buffer[compare_pos]);
 }
 }
 }

 return 0;
}
</code></pre>

Source file was trim.c. Compiled with 'cc -Wall trim.c -o trim'.

blocks|key|1746547|text|我只包含代码，因为到目前为止发布的代码似乎不是最优的(我还没有代表对此发表评论)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1746548|void+inplace_trim(char*+s)
{
++++int+start,+end+=+strlen(s);
++++for+(start+=+0;+isspace(s[start]);+%2B%2Bstart)+{}
++++if+(s[start])+{
++++++++while+(end+>+0+&&+isspace(s[end-1]))
++++++++++++--end;
++++++++memmove(s,+&s[start],+end+-+start);
++++}
++++s[end+-+start]+=+'\0';
}

char*+copy_trim(const+char*+s)
{
++++int+start,+end;
++++for+(start+=+0;+isspace(s[start]);+%2B%2Bstart)+{}
++++for+(end+=+strlen(s);+end+>+0+&&+isspace(s[end-1]);+--end)+{}
++++return+strndup(s+%2B+start,+end+-+start);
}|code-block|syntax|javascript|1746549|strndup()是一个GNU扩展。如果你没有它或类似的东西，你可以自己滚动。例如：|offset|length|style|CODE|1746550|r+=+strdup(s+%2B+start);
r[end-start]+=+'\0';|1746551|entityMap^0|0|0|0|9|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@$I|T|J|U|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

I'm only including code because the code posted so far seems suboptimal (and I don't have the rep to comment yet.)

<pre><code>void inplace_trim(char* s)
{
 int start, end = strlen(s);
 for (start = 0; isspace(s[start]); ++start) {}
 if (s[start]) {
 while (end &gt; 0 &amp;&amp; isspace(s[end-1]))
 --end;
 memmove(s, &amp;s[start], end - start);
 }
 s[end - start] = '\0';
}

char* copy_trim(const char* s)
{
 int start, end;
 for (start = 0; isspace(s[start]); ++start) {}
 for (end = strlen(s); end &gt; 0 &amp;&amp; isspace(s[end-1]); --end) {}
 return strndup(s + start, end - start);
}
</code></pre>

<code>strndup()</code> is a GNU extension. If you don't have it or something equivalent, roll your own. For example:

<pre><code>r = strdup(s + start);
r[end-start] = '\0';
</code></pre>

blocks|key|1531621|text|我的解决方案。字符串必须是可更改的。其他一些解决方案的优点是，它将非空格部分移动到开头，以便您可以继续使用旧指针，以防以后必须释放它()。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1531622|void+trim(char+*+s)+{
++++char+*+p+=+s;
++++int+l+=+strlen(p);

++++while(isspace(p[l+-+1]))+p[--l]+=+0;
++++while(*+p+&&+isspace(*+p))+%2B%2Bp,+--l;

++++memmove(s,+p,+l+%2B+1);
}+++|code-block|syntax|javascript|1531623|此版本使用strndup()创建字符串的副本，而不是就地编辑它。strndup()需要_GNU_SOURCE，所以你可能需要用malloc()和strncpy()来创建你自己的strndup()。|1531624|char+*+trim(char+*+s)+{
++++int+l+=+strlen(s);

++++while(isspace(s[l+-+1]))+--l;
++++while(*+s+&&+isspace(*+s))+%2B%2Bs,+--l;

++++return+strndup(s,+l);
}|1531625|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

My solution. String must be changeable. The advantage above some of the other solutions that it moves the non-space part to the beginning so you can keep using the old pointer, in case you have to free() it later.

<pre><code>void trim(char * s) {
 char * p = s;
 int l = strlen(p);

 while(isspace(p[l - 1])) p[--l] = 0;
 while(* p &amp;&amp; isspace(* p)) ++p, --l;

 memmove(s, p, l + 1);
} 
</code></pre>

This version creates a copy of the string with strndup() instead of editing it in place. strndup() requires _GNU_SOURCE, so maybe you need to make your own strndup() with malloc() and strncpy().

<pre><code>char * trim(char * s) {
 int l = strlen(s);

 while(isspace(s[l - 1])) --l;
 while(* s &amp;&amp; isspace(* s)) ++s, --l;

 return strndup(s, l);
}
</code></pre>

blocks|key|1531671|text|使用string+library，例如：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1531672|Ustr+*s1+=+USTR1(\7,+"+12345+");

ustr_sc_trim_cstr(&s1,+"+");
assert(ustr_cmp_cstr_eq(s1,+"12345"));|code-block|syntax|javascript|1531673|...as你说这是一个“常见的”问题，是的，你需要包括一个#include或类似的东西，它没有包含在libc中，但不要去发明你自己的黑客作业来存储随机指针和大小_t，那样只会导致缓冲区溢出。|1531674|entityMap|0|LINK|mutability|MUTABLE|url|http://www.and.org/vstr/comparison^0|2|E|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]]|C|$]]|$1|D|3|E|5|F|7|W|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|X|8|@]|9|@]|C|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]]]

Use a <a href="http://www.and.org/vstr/comparison" rel="nofollow noreferrer">string library</a>, for instance:

<pre><code>Ustr *s1 = USTR1(\7, " 12345 ");

ustr_sc_trim_cstr(&s1, " ");
assert(ustr_cmp_cstr_eq(s1, "12345"));</code></pre>

...as you say this is a "common" problem, yes you need to include a #include or so and it's not included in libc but don't go inventing your own hack job storing random pointers and size_t's that way only leads to buffer overflows.

blocks|key|1746700|text|#include+"stdafx.h"
#include+"malloc.h"
#include+"string.h"

int+main(int+argc,+char*+argv[])
{

++char+*ptr+=+(char*)malloc(sizeof(char)*30);
++strcpy(ptr,"++++++++++++Hel++lo++++wo+++++++++++rl+++d+G++++eo+rocks!!!++++by+shahil++++sucks+b+i++++++++++g+++++++tim+++++++++++e");

++int+i+=+0,+j+=+0;

++while(ptr[j]!='\0')
++{

++++++if(ptr[j]+==+'+'+)
++++++{
++++++++++j%2B%2B;
++++++++++ptr[i]+=+ptr[j];
++++++}
++++++else
++++++{
++++++++++i%2B%2B;
++++++++++j%2B%2B;
++++++++++ptr[i]+=+ptr[j];
++++++}
++}


++printf("\noutput-%25s\n",ptr);
++++++++return+0;
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1746701|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>#include "stdafx.h"
#include "malloc.h"
#include "string.h"

int main(int argc, char* argv[])
{

 char *ptr = (char*)malloc(sizeof(char)*30);
 strcpy(ptr," Hel lo wo rl d G eo rocks!!! by shahil sucks b i g tim e");

 int i = 0, j = 0;

 while(ptr[j]!='\0')
 {

 if(ptr[j] == ' ' )
 {
 j++;
 ptr[i] = ptr[j];
 }
 else
 {
 i++;
 j++;
 ptr[i] = ptr[j];
 }
 }


 printf("\noutput-%s\n",ptr);
 return 0;
}</code></pre>

blocks|key|1531746|text|这个游戏有点晚了，但我会把我的常规投入到竞争中。它们可能不是最有效的，但我相信它们是正确的，它们很简单(+rtrim()突破了复杂性的极限)：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1531747|#include+<ctype.h>
#include+<string.h>

/*
++++Public+domain+implementations+of+in-place+string+trim+functions

++++Michael+Burr
++++michael.burr@nth-element.com
++++2010
*/

char*+ltrim(char*+s)+
{
++++char*+newstart+=+s;

++++while+(isspace(+*newstart))+{
++++++++%2B%2Bnewstart;
++++}

++++//+newstart+points+to+first+non-whitespace+char+(which+might+be+'\0')
++++memmove(+s,+newstart,+strlen(+newstart)+%2B+1);+//+don't+forget+to+move+the+'\0'+terminator

++++return+s;
}


char*+rtrim(+char*+s)
{
++++char*+end+=+s+%2B+strlen(+s);

++++//+find+the+last+non-whitespace+character
++++while+((end+!=+s)+&&+isspace(+*(end-1)))+{
++++++++++++--end;
++++}

++++//+at+this+point+either+(end+==+s)+and+s+is+either+empty+or+all+whitespace
++++//++++++so+it+needs+to+be+made+empty,+or
++++//++++++end+points+just+past+the+last+non-whitespace+character+(it+might+point
++++//++++++at+the+'\0'+terminator,+in+which+case+there's+no+problem+writing
++++//++++++another+there).++++
++++*end+=+'\0';

++++return+s;
}

char*++trim(+char*+s)
{
++++return+rtrim(+ltrim(+s));
}|code-block|syntax|javascript|1531748|entityMap^0|1H|7|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

A bit late to the game, but I'll throw my routines into the fray. They're probably not the most absolute efficient, but I believe they're correct and they're simple (with <code>rtrim()</code> pushing the complexity envelope):

<pre><code>#include &lt;ctype.h&gt;
#include &lt;string.h&gt;

/*
 Public domain implementations of in-place string trim functions

 Michael Burr
 michael.burr@nth-element.com
 2010
*/

char* ltrim(char* s) 
{
 char* newstart = s;

 while (isspace( *newstart)) {
 ++newstart;
 }

 // newstart points to first non-whitespace char (which might be '\0')
 memmove( s, newstart, strlen( newstart) + 1); // don't forget to move the '\0' terminator

 return s;
}


char* rtrim( char* s)
{
 char* end = s + strlen( s);

 // find the last non-whitespace character
 while ((end != s) &amp;&amp; isspace( *(end-1))) {
 --end;
 }

 // at this point either (end == s) and s is either empty or all whitespace
 // so it needs to be made empty, or
 // end points just past the last non-whitespace character (it might point
 // at the '\0' terminator, in which case there's no problem writing
 // another there). 
 *end = '\0';

 return s;
}

char* trim( char* s)
{
 return rtrim( ltrim( s));
}
</code></pre>

blocks|key|1746778|text|这是我尝试的一个简单但正确的就地修剪函数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1746779|void+trim(char+*str)
{
++++int+i;
++++int+begin+=+0;
++++int+end+=+strlen(str)+-+1;

++++while+(isspace((unsigned+char)+str[begin]))
++++++++begin%2B%2B;

++++while+((end+>=+begin)+&&+isspace((unsigned+char)+str[end]))
++++++++end--;

++++//+Shift+all+characters+back+to+the+start+of+the+string+array.
++++for+(i+=+begin;+i+<=+end;+i%2B%2B)
++++++++str[i+-+begin]+=+str[i];

++++str[i+-+begin]+=+'\0';+//+Null+terminate+string.
}|code-block|syntax|javascript|1746780|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here is my attempt at a simple, yet correct in-place trim function.

<pre><code>void trim(char *str)
{
 int i;
 int begin = 0;
 int end = strlen(str) - 1;

 while (isspace((unsigned char) str[begin]))
 begin++;

 while ((end &gt;= begin) &amp;&amp; isspace((unsigned char) str[end]))
 end--;

 // Shift all characters back to the start of the string array.
 for (i = begin; i &lt;= end; i++)
 str[i - begin] = str[i];

 str[i - begin] = '\0'; // Null terminate string.
}
</code></pre>

blocks|key|1531826|text|这里有一个类似于@adam-rosenfields就地修改例程的解决方案，但不需要求助于strlen()。与@jkramer类似，字符串在缓冲区中进行左调整，因此您可以释放相同的指针。对于大型字符串不是最优的，因为它不使用memmove。包括@jfm3提到的%2B%2B/--运算符。包括FCTX-based单元测试。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1531827|#include+<ctype.h>

void+trim(char+*+const+a)
{
++++char+*p+=+a,+*q+=+a;
++++while+(isspace(*q))++++++++++++%2B%2Bq;
++++while+(*q)+++++++++++++++++++++*p%2B%2B+=+*q%2B%2B;
++++*p+=+'\0';
++++while+(p+>+a+&&+isspace(*--p))+*p+=+'\0';
}

/*+See+http://fctx.wildbearsoftware.com/+*/
#include+"fct.h"

FCT_BGN()
{
++++FCT_QTEST_BGN(trim)
++++{
++++++++{+char+s[]+=+"";++++++trim(s);+fct_chk_eq_str("",++++s);+}+//+Trivial
++++++++{+char+s[]+=+"+++";+++trim(s);+fct_chk_eq_str("",++++s);+}+//+Trivial
++++++++{+char+s[]+=+"\t";++++trim(s);+fct_chk_eq_str("",++++s);+}+//+Trivial
++++++++{+char+s[]+=+"a";+++++trim(s);+fct_chk_eq_str("a",+++s);+}+//+NOP
++++++++{+char+s[]+=+"abc";+++trim(s);+fct_chk_eq_str("abc",+s);+}+//+NOP
++++++++{+char+s[]+=+"++a";+++trim(s);+fct_chk_eq_str("a",+++s);+}+//+Leading
++++++++{+char+s[]+=+"++a+c";+trim(s);+fct_chk_eq_str("a+c",+s);+}+//+Leading
++++++++{+char+s[]+=+"a++";+++trim(s);+fct_chk_eq_str("a",+++s);+}+//+Trailing
++++++++{+char+s[]+=+"a+c++";+trim(s);+fct_chk_eq_str("a+c",+s);+}+//+Trailing
++++++++{+char+s[]+=+"+a+";+++trim(s);+fct_chk_eq_str("a",+++s);+}+//+Both
++++++++{+char+s[]+=+"+a+c+";+trim(s);+fct_chk_eq_str("a+c",+s);+}+//+Both

++++++++//+Villemoes+pointed+out+an+edge+case+that+corrupted+memory.++Thank+you.
++++++++//+http://stackoverflow.com/questions/122616/#comment23332594_4505533
++++++++{
++++++++++char+s[]+=+"a+++++";+++++++//+Buffer+with+whitespace+before+s+%2B+2
++++++++++trim(s+%2B+2);+++++++++++++++//+Trim+"++++"+containing+only+whitespace
++++++++++fct_chk_eq_str("",+s+%2B+2);+//+Ensure+correct+result+from+the+trim
++++++++++fct_chk_eq_str("a+",+s);+++//+Ensure+preceding+buffer+not+mutated
++++++++}

++++++++//+doukremt+suggested+I+investigate+this+test+case+but
++++++++//+did+not+indicate+the+specific+behavior+that+was+objectionable.
++++++++//+http://stackoverflow.com/posts/comments/33571430
++++++++{
++++++++++char+s[]+=+"+++++++++foobar";++//+Shifted+across+whitespace
++++++++++trim(s);+++++++++++++++++++++++//+Trim
++++++++++fct_chk_eq_str("foobar",+s);+++//+Leading+string+is+correct

++++++++++//+Here+is+what+the+algorithm+produces:
++++++++++char+r[16]+=+{+'f',+'o',+'o',+'b',+'a',+'r',+'\0',+'+',+++++++++++++++++++++
+++++++++++++++++++++++++'+',+'f',+'o',+'o',+'b',+'a',+'r',+'\0'};
++++++++++fct_chk_eq_int(0,+memcmp(s,+r,+sizeof(s)));
++++++++}
++++}
++++FCT_QTEST_END();
}
FCT_END();|code-block|syntax|javascript|1531828|entityMap|0|LINK|mutability|MUTABLE|url|http://fctx.wildbearsoftware.com/^0|3W|4|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

Here's a solution similar to @adam-rosenfields in-place modification routine but without needlessly resorting to strlen(). Like @jkramer, the string is left-adjusted within the buffer so you can free the same pointer. Not optimal for large strings since it does not use memmove. Includes the ++/-- operators that @jfm3 mentions. <a href="http://fctx.wildbearsoftware.com" rel="nofollow">FCTX</a>-based unit tests included.

<pre><code>#include &lt;ctype.h&gt;

void trim(char * const a)
{
 char *p = a, *q = a;
 while (isspace(*q)) ++q;
 while (*q) *p++ = *q++;
 *p = '\0';
 while (p &gt; a &amp;&amp; isspace(*--p)) *p = '\0';
}

/* See http://fctx.wildbearsoftware.com/ */
#include "fct.h"

FCT_BGN()
{
 FCT_QTEST_BGN(trim)
 {
 { char s[] = ""; trim(s); fct_chk_eq_str("", s); } // Trivial
 { char s[] = " "; trim(s); fct_chk_eq_str("", s); } // Trivial
 { char s[] = "\t"; trim(s); fct_chk_eq_str("", s); } // Trivial
 { char s[] = "a"; trim(s); fct_chk_eq_str("a", s); } // NOP
 { char s[] = "abc"; trim(s); fct_chk_eq_str("abc", s); } // NOP
 { char s[] = " a"; trim(s); fct_chk_eq_str("a", s); } // Leading
 { char s[] = " a c"; trim(s); fct_chk_eq_str("a c", s); } // Leading
 { char s[] = "a "; trim(s); fct_chk_eq_str("a", s); } // Trailing
 { char s[] = "a c "; trim(s); fct_chk_eq_str("a c", s); } // Trailing
 { char s[] = " a "; trim(s); fct_chk_eq_str("a", s); } // Both
 { char s[] = " a c "; trim(s); fct_chk_eq_str("a c", s); } // Both

 // Villemoes pointed out an edge case that corrupted memory. Thank you.
 // http://stackoverflow.com/questions/122616/#comment23332594_4505533
 {
 char s[] = "a "; // Buffer with whitespace before s + 2
 trim(s + 2); // Trim " " containing only whitespace
 fct_chk_eq_str("", s + 2); // Ensure correct result from the trim
 fct_chk_eq_str("a ", s); // Ensure preceding buffer not mutated
 }

 // doukremt suggested I investigate this test case but
 // did not indicate the specific behavior that was objectionable.
 // http://stackoverflow.com/posts/comments/33571430
 {
 char s[] = " foobar"; // Shifted across whitespace
 trim(s); // Trim
 fct_chk_eq_str("foobar", s); // Leading string is correct

 // Here is what the algorithm produces:
 char r[16] = { 'f', 'o', 'o', 'b', 'a', 'r', '\0', ' ', 
 ' ', 'f', 'o', 'o', 'b', 'a', 'r', '\0'};
 fct_chk_eq_int(0, memcmp(s, r, sizeof(s)));
 }
 }
 FCT_QTEST_END();
}
FCT_END();
</code></pre>

blocks|key|1531843|text|#include<stdio.h>
#include<ctype.h>

main()
{
++++char+sent[10]={'+','+','+','s','t','a','r','s','+','+'};
++++int+i,j=0;
++++char+rec[10];

++++for(i=0;i<=10;i%2B%2B)
++++{
++++++++if(!isspace(sent[i]))
++++++++{

++++++++++++rec[j]=sent[i];
++++++++++++j%2B%2B;
++++++++}
++++}

printf("\n%25s\n",rec);

}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1531844|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>#include&lt;stdio.h&gt;
#include&lt;ctype.h&gt;

main()
{
 char sent[10]={' ',' ',' ','s','t','a','r','s',' ',' '};
 int i,j=0;
 char rec[10];

 for(i=0;i&lt;=10;i++)
 {
 if(!isspace(sent[i]))
 {

 rec[j]=sent[i];
 j++;
 }
 }

printf("\n%s\n",rec);

}
</code></pre>

blocks|key|1531884|text|这是我能想到的最短的实现：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1531885|static+const+char+*WhiteSpace="+\n\r\t";
char*+trim(char+*t)
{
++++char+*e=t%2B(t!=NULL?strlen(t):0);+++++++++++++++//+*e+initially+points+to+end+of+string
++++if+(t==NULL)+return;
++++do+--e;+while+(strchr(WhiteSpace,+*e)+&&+e>=t);++//+Find+last+char+that+is+not+\r\n\t
++++*(%2B%2Be)=0;++++++++++++++++++++++++++++++++++++++//+Null-terminate
++++e=t%2Bstrspn+(t,WhiteSpace);+++++++++++++++++++++++++++//+Find+first+char+that+is+not+\t
++++return+e>t?memmove(t,e,strlen(e)%2B1):t;++++++++++++++++++//+memmove+string+contents+and+terminator
}|code-block|syntax|javascript|1531886|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

This is the shortest possible implementation I can think of:

<pre><code>static const char *WhiteSpace=" \n\r\t";
char* trim(char *t)
{
 char *e=t+(t!=NULL?strlen(t):0); // *e initially points to end of string
 if (t==NULL) return;
 do --e; while (strchr(WhiteSpace, *e) &amp;&amp; e&gt;=t); // Find last char that is not \r\n\t
 *(++e)=0; // Null-terminate
 e=t+strspn (t,WhiteSpace); // Find first char that is not \t
 return e&gt;t?memmove(t,e,strlen(e)+1):t; // memmove string contents and terminator
}
</code></pre>

blocks|key|1531926|text|这些函数将修改原始缓冲区，因此如果动态分配，则可以释放原始指针。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1531927|#include+<string.h>

void+rstrip(char+*string)
{
++int+l;
++if+(!string)
++++return;
++l+=+strlen(string)+-+1;
++while+(isspace(string[l])+&&+l+>=+0)
++++string[l--]+=+0;
}

void+lstrip(char+*string)
{
++int+i,+l;
++if+(!string)
++++return;
++l+=+strlen(string);
++while+(isspace(string[(i+=+0)]))
++++while(i%2B%2B+<+l)
++++++string[i-1]+=+string[i];
}

void+strip(char+*string)
{
++lstrip(string);
++rstrip(string);
}|code-block|syntax|javascript|1531928|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

These functions will modify the original buffer, so if dynamically allocated, the original
pointer can be freed.

<pre><code>#include &lt;string.h&gt;

void rstrip(char *string)
{
 int l;
 if (!string)
 return;
 l = strlen(string) - 1;
 while (isspace(string[l]) &amp;&amp; l &gt;= 0)
 string[l--] = 0;
}

void lstrip(char *string)
{
 int i, l;
 if (!string)
 return;
 l = strlen(string);
 while (isspace(string[(i = 0)]))
 while(i++ &lt; l)
 string[i-1] = string[i];
}

void strip(char *string)
{
 lstrip(string);
 rstrip(string);
}
</code></pre>

blocks|key|1531982|text|你对使用头文件Shlwapi.h中定义的StrTrim函数有什么看法？它是直接的，而不是你自己定义的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1531983|有关详细信息，请访问：|1531984|http://msdn.microsoft.com/en-us/library/windows/desktop/bb773454(v=vs.85).aspx|offset|length|1531985|如果你有|1531986|char+ausCaptain[]="GeorgeBailey++";|style|CODE|1531987|StrTrim(ausCaptain,"+");|1531988|这将使ausCaptain成为"GeorgeBailey"而不是"GeorgeBailey++"。|1531989|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|0|26|0|0|0|0|Z|0|0|O|0|3|A|F|E|W|G|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Z|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|10|8|@]|9|@$F|11|G|12|1|13]]|A|$]]|$1|H|3|I|5|6|7|14|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|15|8|@$F|16|G|17|L|M]]|9|@]|A|$]]|$1|N|3|O|5|6|7|18|8|@$F|19|G|1A|L|M]]|9|@]|A|$]]|$1|P|3|Q|5|6|7|1B|8|@$F|1C|G|1D|L|M]|$F|1E|G|1F|L|M]|$F|1G|G|1H|L|M]]|9|@]|A|$]]|$1|R|3|-4|5|6|7|1I|8|@]|9|@]|A|$]]]|S|$T|$5|U|V|W|A|$X|E]]]]

What do you think about using StrTrim function defined in header Shlwapi.h.? It is straight forward rather defining on your own. 
Details can be found on: 
 <a href="http://msdn.microsoft.com/en-us/library/windows/desktop/bb773454(v=vs.85).aspx" rel="nofollow">http://msdn.microsoft.com/en-us/library/windows/desktop/bb773454(v=vs.85).aspx</a> 

If you have 
<code>char ausCaptain[]="GeorgeBailey ";</code> 
<code>StrTrim(ausCaptain," ");</code> 
This will give <code>ausCaptain</code> as <code>"GeorgeBailey"</code> not <code>"GeorgeBailey "</code>.

blocks|key|1532040|text|另一个，只有一行代码做真正的工作：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1532041|#include+<stdio.h>

int+main()
{
+++const+char+*target+=+"+++haha+++";
+++char+buf[256];
+++sscanf(target,+"%25s",+buf);+//+Trimming+on+both+sides+occurs+here
+++printf("<%25s>\n",+buf);
}|code-block|syntax|javascript|1532042|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Another one, with one line doing the real job:

<pre><code>#include &lt;stdio.h&gt;

int main()
{
 const char *target = " haha ";
 char buf[256];
 sscanf(target, "%s", buf); // Trimming on both sides occurs here
 printf("&lt;%s&gt;\n", buf);
}
</code></pre>

blocks|key|1747143|text|以下是我在Linux内核代码中披露的问题：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1747144|/**
+*+skip_spaces+-+Removes+leading+whitespace+from+@s.
+*+@s:+The+string+to+be+stripped.
+*
+*+Returns+a+pointer+to+the+first+non-whitespace+character+in+@s.
+*/
char+*skip_spaces(const+char+*str)
{
++++while+(isspace(*str))
++++++++++++%2B%2Bstr;
++++return+(char+*)str;
}

/**
+*+strim+-+Removes+leading+and+trailing+whitespace+from+@s.
+*+@s:+The+string+to+be+stripped.
+*
+*+Note+that+the+first+trailing+whitespace+is+replaced+with+a+%25NUL-terminator
+*+in+the+given+string+@s.+Returns+a+pointer+to+the+first+non-whitespace
+*+character+in+@s.
+*/
char+*strim(char+*s)
{
++++size_t+size;
++++char+*end;

++++size+=+strlen(s);

++++if+(!size)
++++++++++++return+s;

++++end+=+s+%2B+size+-+1;
++++while+(end+>=+s+&&+isspace(*end))
++++++++++++end--;
++++*(end+%2B+1)+=+'\0';

++++return+skip_spaces(s);
}|code-block|syntax|javascript|1747145|由于它的来源，它应该是无bug的;-)|1747146|我想我的一条更接近于亲吻原则：|1747147|/**
+*+trim+spaces
+**/
char+*+trim_inplace(char+*+s,+int+len)
{
++++//+trim+leading
++++while+(len+&&+isspace(s[0]))
++++{
++++++++s%2B%2B;+len--;
++++}

++++//+trim+trailing
++++while+(len+&&+isspace(s[len+-+1]))
++++{
++++++++s[len+-+1]+=+0;+len--;
++++}

++++return+s;
}|1747148|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|S|8|@]|9|@]|A|$E|F]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Here is what I disclosed regarding the question in Linux kernel code:

<pre><code>/**
 * skip_spaces - Removes leading whitespace from @s.
 * @s: The string to be stripped.
 *
 * Returns a pointer to the first non-whitespace character in @s.
 */
char *skip_spaces(const char *str)
{
 while (isspace(*str))
 ++str;
 return (char *)str;
}

/**
 * strim - Removes leading and trailing whitespace from @s.
 * @s: The string to be stripped.
 *
 * Note that the first trailing whitespace is replaced with a %NUL-terminator
 * in the given string @s. Returns a pointer to the first non-whitespace
 * character in @s.
 */
char *strim(char *s)
{
 size_t size;
 char *end;

 size = strlen(s);

 if (!size)
 return s;

 end = s + size - 1;
 while (end &gt;= s &amp;&amp; isspace(*end))
 end--;
 *(end + 1) = '\0';

 return skip_spaces(s);
}
</code></pre>

It is supposed to be bug free due to the origin ;-)

Mine one piece is closer to KISS principle I guess:

<pre><code>/**
 * trim spaces
 **/
char * trim_inplace(char * s, int len)
{
 // trim leading
 while (len &amp;&amp; isspace(s[0]))
 {
 s++; len--;
 }

 // trim trailing
 while (len &amp;&amp; isspace(s[len - 1]))
 {
 s[len - 1] = 0; len--;
 }

 return s;
}
</code></pre>

blocks|key|1747206|text|为了保持增长，还有一个带有可修改字符串的选项：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1747207|void+trimString(char+*string)
{
++++size_t+i+=+0,+j+=+strlen(string);
++++while+(j+>+0+&&+isspace((unsigned+char)string[j+-+1]))+string[--j]+=+'\0';
++++while+(isspace((unsigned+char)string[i]))+i%2B%2B;
++++if+(i+>+0)+memmove(string,+string+%2B+i,+j+-+i+%2B+1);
}|code-block|syntax|javascript|1747208|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Just to keep this growing, one more option with a modifiable string:

<pre><code>void trimString(char *string)
{
 size_t i = 0, j = strlen(string);
 while (j &gt; 0 &amp;&amp; isspace((unsigned char)string[j - 1])) string[--j] = '\0';
 while (isspace((unsigned char)string[i])) i++;
 if (i &gt; 0) memmove(string, string + i, j - i + 1);
}
</code></pre>

blocks|key|1747244|text|C%2B%2B+STL样式|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1747245|std::string+Trimed(const+std::string&+s)
{
++++std::string::const_iterator+begin+=+std::find_if(s.begin(),
+++++++++++++++++++++++++++++++++++++++++++++++++s.end(),
+++++++++++++++++++++++++++++++++++++++++++++++++[](char+ch)+{+return+!std::isspace(ch);+});

++++std::string::const_iterator+++end+=+std::find_if(s.rbegin(),
+++++++++++++++++++++++++++++++++++++++++++++++++s.rend(),
+++++++++++++++++++++++++++++++++++++++++++++++++[](char+ch)+{+return+!std::isspace(ch);+}).base();
++++return+std::string(begin,+end);
}|code-block|syntax|javascript|1747246|http://ideone.com/VwJaq9|offset|length|1747247|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|0|O|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|S|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|T|8|@]|9|@$I|U|J|V|1|W]]|A|$]]|$1|K|3|-4|5|6|7|X|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|H]]]]

C++ STL style

<pre><code>std::string Trimed(const std::string&amp; s)
{
 std::string::const_iterator begin = std::find_if(s.begin(),
 s.end(),
 [](char ch) { return !std::isspace(ch); });

 std::string::const_iterator end = std::find_if(s.rbegin(),
 s.rend(),
 [](char ch) { return !std::isspace(ch); }).base();
 return std::string(begin, end);
}
</code></pre>

<a href="http://ideone.com/VwJaq9" rel="nofollow">http://ideone.com/VwJaq9</a>

blocks|key|1532342|text|void+trim(char*+const+str)
{
++++char*+begin+=+str;
++++char*+end+=+str;
++++while+(isspace(*begin))
++++{
++++++++%2B%2Bbegin;
++++}
++++char*+s+=+begin;
++++while+(*s+!=+'\0')
++++{
++++++++if+(!isspace(*s%2B%2B))
++++++++{
++++++++++++end+=+s;
++++++++}
++++}
++++*end+=+'\0';
++++const+int+dist+=+end+-+begin;
++++if+(begin+>+str+&&+dist+>+0)
++++{
++++++++memmove(str,+begin,+dist+%2B+1);
++++}
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1532343|就地修改字符串，因此您仍然可以删除它。|unstyled|1532344|不使用花哨的库函数(除非你认为memmove很花哨)。|1532345|处理字符串重叠。|1532346|前后修剪(不是中间，抱歉)。|1532347|如果字符串很大(memmove通常是用汇编语言编写的)，则快速。|1532348|只有在需要时才移动字符(我发现这在大多数用例中是正确的，因为字符串很少有前导空格，而且通常没有尾随空格)|1532349|我想测试一下，但是我要迟到了。享受寻找bug的乐趣。:-)|1532350|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|V|8|@]|9|@]|A|$]]|$1|G|3|H|5|F|7|W|8|@]|9|@]|A|$]]|$1|I|3|J|5|F|7|X|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|Y|8|@]|9|@]|A|$]]|$1|M|3|N|5|F|7|Z|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|10|8|@]|9|@]|A|$]]|$1|Q|3|R|5|F|7|11|8|@]|9|@]|A|$]]|$1|S|3|-4|5|F|7|12|8|@]|9|@]|A|$]]]|T|$]]

<pre><code>void trim(char* const str)
{
 char* begin = str;
 char* end = str;
 while (isspace(*begin))
 {
 ++begin;
 }
 char* s = begin;
 while (*s != '\0')
 {
 if (!isspace(*s++))
 {
 end = s;
 }
 }
 *end = '\0';
 const int dist = end - begin;
 if (begin &gt; str &amp;&amp; dist &gt; 0)
 {
 memmove(str, begin, dist + 1);
 }
}
</code></pre>

Modifies string in place, so you can still delete it. 

Doesn't use fancy pants library functions (unless you consider memmove fancy).

Handles string overlap.

Trims front and back (not middle, sorry).

Fast if string is large (memmove often written in assembly).

Only moves characters if required (I find this true in most use cases because strings rarely have leading spaces and often don't have tailing spaces)

I would like to test this but I'm running late. Enjoy finding bugs... :-)

blocks|key|1747404|text|为了从两边修剪我的字符串，我使用旧的，但好的;)它可以修剪任何ascii小于一个空格的东西，这意味着控制字符也将被修剪！|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1747405|char+*trimAll(char+*strData)
{
++unsigned+int+L+=+strlen(strData);
++if(L+>+0){+L--;+}else{+return+strData;+}
++size_t+S+=+0,+E+=+L;
++while((!(strData[S]+>+'+')+%7C%7C+!(strData[E]+>+'+'))+&&+(S+>=+0)+&&+(S+<=+L)+&&+(E+>=+0)+&&+(E+<=+L))
++{
++++if(strData[S]+<=+'+'){+S%2B%2B;+}
++++if(strData[E]+<=+'+'){+E--;+}
++}
++if(S+==+0+&&+E+==+L){+return+strData;+}+//+Nothing+to+be+done
++if((S+>=+0)+&&+(S+<=+L)+&&+(E+>=+0)+&&+(E+<=+L)){
++++L+=+E+-+S+%2B+1;
++++memmove(strData,&strData[S],L);+strData[L]+=+'\0';
++}else{+strData[0]+=+'\0';+}
++return+strData;
}|code-block|syntax|javascript|1747406|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

To trim my strings from the both sides I use the oldie but the gooody ;)
It can trim anything with ascii less than a space, meaning that the control chars will be trimmed also !

<pre><code>char *trimAll(char *strData)
{
 unsigned int L = strlen(strData);
 if(L &gt; 0){ L--; }else{ return strData; }
 size_t S = 0, E = L;
 while((!(strData[S] &gt; ' ') || !(strData[E] &gt; ' ')) &amp;&amp; (S &gt;= 0) &amp;&amp; (S &lt;= L) &amp;&amp; (E &gt;= 0) &amp;&amp; (E &lt;= L))
 {
 if(strData[S] &lt;= ' '){ S++; }
 if(strData[E] &lt;= ' '){ E--; }
 }
 if(S == 0 &amp;&amp; E == L){ return strData; } // Nothing to be done
 if((S &gt;= 0) &amp;&amp; (S &lt;= L) &amp;&amp; (E &gt;= 0) &amp;&amp; (E &lt;= L)){
 L = E - S + 1;
 memmove(strData,&amp;strData[S],L); strData[L] = '\0';
 }else{ strData[0] = '\0'; }
 return strData;
}
</code></pre>

blocks|key|1532456|text|void+trim(char*+string)+{
++++int+lenght+=+strlen(string);
++++int+i=0;

++++while(string[0]+=='+')+{
++++++++for(i=0;+i<lenght;+i%2B%2B)+{
++++++++++++string[i]+=+string[i%2B1];
++++++++}
++++++++lenght--;
++++}


++++for(i=lenght-1;+i>0;+i--)+{
++++++++if(string[i]+==+'+')+{
++++++++++++string[i]+=+'\0';
++++++++}+else+{
++++++++++++break;
++++++++}
++++}
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1532457|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>void trim(char* string) {
 int lenght = strlen(string);
 int i=0;

 while(string[0] ==' ') {
 for(i=0; i&lt;lenght; i++) {
 string[i] = string[i+1];
 }
 lenght--;
 }


 for(i=lenght-1; i&gt;0; i--) {
 if(string[i] == ' ') {
 string[i] = '\0';
 } else {
 break;
 }
 }
}
</code></pre>

blocks|key|1532538|text|如果您使用的是glib，那么您可以使用g_strstrip|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1532539|entityMap|0|LINK|mutability|MUTABLE|url|https://developer.gnome.org/glib/stable/glib-String-Utility-Functions.html#g-strstrip^0|7|4|J|A|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]]|D|@$9|Q|A|R|1|S]]|E|$]]|$1|F|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|G|$H|$5|I|J|K|E|$L|M]]]]

If you're using <code>glib</code>, then you can use <a href="https://developer.gnome.org/glib/stable/glib-String-Utility-Functions.html#g-strstrip" rel="nofollow">g_strstrip</a>

blocks|key|1747585|text|我知道有很多答案，但我在这里发布我的答案，看看我的解决方案是否足够好。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1747586|//+Trims+leading+whitespace+chars+in+left+`str`,+then+copy+at+almost+`n+-+1`+chars
//+into+the+`out`+buffer+in+which+copying+might+stop+when+the+first+'\0'+occurs,+
//+and+finally+append+'\0'+to+the+position+of+the+last+non-trailing+whitespace+char.
//+Reture+the+length+the+trimed+string+which+'\0'+is+not+count+in+like+strlen().
size_t+trim(char+*out,+size_t+n,+const+char+*str)
{
++++//+do+nothing
++++if(n+==+0)+return+0;++++

++++//+ptr+stop+at+the+first+non-leading+space+char
++++while(isspace(*str))+str%2B%2B;++++

++++if(*str+==+'\0')+{
++++++++out[0]+=+'\0';
++++++++return+0;
++++}++++

++++size_t+i+=+0;++++

++++//+copy+char+to+out+until+'\0'+or+i+==+n+-+1
++++for(i+=+0;+i+<+n+-+1+&&+*str+!=+'\0';+i%2B%2B){
++++++++out[i]+=+*str%2B%2B;
++++}++++

++++//+deal+with+the+trailing+space
++++while(isspace(out[--i]));++++

++++out[%2B%2Bi]+=+'\0';
++++return+i;
}|code-block|syntax|javascript|1747587|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I know there have many answers, but I post my answer here to see if my solution is good enough. 

<pre><code>// Trims leading whitespace chars in left `str`, then copy at almost `n - 1` chars
// into the `out` buffer in which copying might stop when the first '\0' occurs, 
// and finally append '\0' to the position of the last non-trailing whitespace char.
// Reture the length the trimed string which '\0' is not count in like strlen().
size_t trim(char *out, size_t n, const char *str)
{
 // do nothing
 if(n == 0) return 0; 

 // ptr stop at the first non-leading space char
 while(isspace(*str)) str++; 

 if(*str == '\0') {
 out[0] = '\0';
 return 0;
 } 

 size_t i = 0; 

 // copy char to out until '\0' or i == n - 1
 for(i = 0; i &lt; n - 1 &amp;&amp; *str != '\0'; i++){
 out[i] = *str++;
 } 

 // deal with the trailing space
 while(isspace(out[--i])); 

 out[++i] = '\0';
 return i;
}
</code></pre>

blocks|key|1532671|text|在这里，我使用动态内存分配来修剪函数trimStr的输入字符串。首先，我们找出输入字符串中有多少个非空字符。然后，我们分配一个具有该大小的字符数组，并处理以null结尾的字符。当我们使用这个函数时，我们需要释放main函数内部的内存。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1532672|#include<stdio.h>
#include<stdlib.h>

char+*trimStr(char+*str){
char+*tmp+=+str;
printf("input+string+%25s\n",str);
int+nc+=+0;

while(*tmp!='\0'){
++if+(*tmp+!=+'+'){
++nc%2B%2B;
+}
+tmp%2B%2B;
}
printf("total+nonempty+characters+are+%25d\n",nc);
char+*trim+=+NULL;

trim+=+malloc(sizeof(char)*(nc%2B1));
if+(trim+==+NULL)+return+NULL;
tmp+=+str;
int+ne+=+0;

while(*tmp!='\0'){
++if+(*tmp+!=+'+'){
+++++trim[ne]+=+*tmp;
+++ne%2B%2B;
+}
+tmp%2B%2B;
}
trim[nc]+=+'\0';

printf("trimmed+string+is+%25s\n",trim);

return+trim;+
+}


int+main(void){

char+str[]+=+"+s+ta+ck+ove+r+fl+o+w++";

char+*trim+=+trimStr(str);

if+(trim+!=+NULL+)free(trim);

return+0;
}|code-block|syntax|javascript|1532673|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here i use the dynamic memory allocation to trim the input string to the function trimStr. First, we find how many non-empty characters exist in the input string. Then, we allocate a character array with that size and taking care of the null terminated character. When we use this function, we need to free the memory inside of main function. 

<pre><code>#include&lt;stdio.h&gt;
#include&lt;stdlib.h&gt;

char *trimStr(char *str){
char *tmp = str;
printf("input string %s\n",str);
int nc = 0;

while(*tmp!='\0'){
 if (*tmp != ' '){
 nc++;
 }
 tmp++;
}
printf("total nonempty characters are %d\n",nc);
char *trim = NULL;

trim = malloc(sizeof(char)*(nc+1));
if (trim == NULL) return NULL;
tmp = str;
int ne = 0;

while(*tmp!='\0'){
 if (*tmp != ' '){
 trim[ne] = *tmp;
 ne++;
 }
 tmp++;
}
trim[nc] = '\0';

printf("trimmed string is %s\n",trim);

return trim; 
 }


int main(void){

char str[] = " s ta ck ove r fl o w ";

char *trim = trimStr(str);

if (trim != NULL )free(trim);

return 0;
}
</code></pre>

blocks|key|1532745|text|跳过字符串中前导空格的最简单方法是，imho，|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1532746|#include+<stdio.h>

int+main()
{
char+*foo="+++++teststring++++++";
char+*bar;
sscanf(foo,"%25s",bar);
printf("String+is+>%25s<\n",bar);
++++return+0;
}|code-block|syntax|javascript|1532747|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

The easiest way to skip leading spaces in a string is, imho,

<pre><code>#include &lt;stdio.h&gt;

int main()
{
char *foo=" teststring ";
char *bar;
sscanf(foo,"%s",bar);
printf("String is &gt;%s&lt;\n",bar);
 return 0;
}
</code></pre>

blocks|key|1532799|text|这就是我是怎么做的。它在适当的位置修剪字符串，因此不必担心释放返回的字符串或丢失指向已分配字符串的指针。这可能不是最简短的答案，但对大多数读者来说应该是清晰的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1532800|#include+<ctype.h>
#include+<string.h>
void+trim_str(char+*s)
{
++++const+size_t+s_len+=+strlen(s);

++++int+i;
++++for+(i+=+0;+i+<+s_len;+i%2B%2B)
++++{
++++++++if+(!isspace(+(unsigned+char)+s[i]+))+break;
++++}

++++if+(i+==+s_len)
++++{
++++++++//+s+is+an+empty+string+or+contains+only+space+characters

++++++++s[0]+=+'\0';
++++}
++++else
++++{
++++++++//+s+contains+non-space+characters

++++++++const+char+*non_space_beginning+=+s+%2B+i;

++++++++char+*non_space_ending+=+s+%2B+s_len+-+1;
++++++++while+(+isspace(+(unsigned+char)+*non_space_ending+)+)+non_space_ending--;

++++++++size_t+trimmed_s_len+=+non_space_ending+-+non_space_beginning+%2B+1;

++++++++if+(s+!=+non_space_beginning)
++++++++{
++++++++++++//+Non-space+characters+exist+in+the+beginning+of+s

++++++++++++memmove(s,+non_space_beginning,+trimmed_s_len);
++++++++}

++++++++s[trimmed_s_len]+=+'\0';
++++}
}|code-block|syntax|javascript|1532801|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here is how I do it. It trims the string in place, so no worry about deallocating a returned string or losing the pointer to an allocated string. It may not be the shortest answer possible, but it should be clear to most readers.

<pre><code>#include &lt;ctype.h&gt;
#include &lt;string.h&gt;
void trim_str(char *s)
{
 const size_t s_len = strlen(s);

 int i;
 for (i = 0; i &lt; s_len; i++)
 {
 if (!isspace( (unsigned char) s[i] )) break;
 }

 if (i == s_len)
 {
 // s is an empty string or contains only space characters

 s[0] = '\0';
 }
 else
 {
 // s contains non-space characters

 const char *non_space_beginning = s + i;

 char *non_space_ending = s + s_len - 1;
 while ( isspace( (unsigned char) *non_space_ending ) ) non_space_ending--;

 size_t trimmed_s_len = non_space_ending - non_space_beginning + 1;

 if (s != non_space_beginning)
 {
 // Non-space characters exist in the beginning of s

 memmove(s, non_space_beginning, trimmed_s_len);
 }

 s[trimmed_s_len] = '\0';
 }
}
</code></pre>

blocks|key|1532826|text|char*+strtrim(char*+const+str)
{
++++if+(str+!=+nullptr)
++++{
++++++++char+const*+begin{+str+};
++++++++while+(std::isspace(*begin))
++++++++{
++++++++++++%2B%2Bbegin;
++++++++}

++++++++auto+end{+begin+};
++++++++auto+scout{+begin+};
++++++++while+(*scout+!=+'\0')
++++++++{
++++++++++++if+(!std::isspace(*scout%2B%2B))
++++++++++++{
++++++++++++++++end+=+scout;
++++++++++++}
++++++++}

++++++++auto+/*+std::ptrdiff_t+*/+const+length{+end+-+begin+};
++++++++if+(begin+!=+str)
++++++++{
++++++++++++std::memmove(str,+begin,+length);
++++++++}

++++++++str[length]+=+'\0';
++++}

++++return+str;
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1532827|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>char* strtrim(char* const str)
{
 if (str != nullptr)
 {
 char const* begin{ str };
 while (std::isspace(*begin))
 {
 ++begin;
 }

 auto end{ begin };
 auto scout{ begin };
 while (*scout != '\0')
 {
 if (!std::isspace(*scout++))
 {
 end = scout;
 }
 }

 auto /* std::ptrdiff_t */ const length{ end - begin };
 if (begin != str)
 {
 std::memmove(str, begin, length);
 }

 str[length] = '\0';
 }

 return str;
}
</code></pre>

blocks|key|1747852|text|好了，这是我对这个问题的看法。我相信这是最简洁的解决方案，在适当的地方修改字符串(free可以工作)，并避免任何UB。对于较小的字符串，它可能比涉及memmove的解决方案更快。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1747853|void+stripWS_LT(char+*str)
{
++++char+*a+=+str,+*b+=+str;
++++while+(isspace((unsigned+char)*a))+a%2B%2B;
++++while+(*b+=+*a%2B%2B)++b%2B%2B;
++++while+(b+>+str+&&+isspace((unsigned+char)*--b))+*b+=+0;
}|code-block|syntax|javascript|1747854|entityMap^0|15|4|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

Ok this is my take on the question. I believe it's the most concise solution that modifies the string in place (<code>free</code> will work) and avoids any UB. For small strings, it's probably faster than a solution involving memmove.

<pre><code>void stripWS_LT(char *str)
{
 char *a = str, *b = str;
 while (isspace((unsigned char)*a)) a++;
 while (*b = *a++) b++;
 while (b &gt; str &amp;&amp; isspace((unsigned char)*--b)) *b = 0;
}
</code></pre>

blocks|key|1532947|text|这段代码简短而简单，使用了for-循环，并且不会覆盖字符串边界。如果需要，您可以将测试替换为isspace()。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1532948|void+trim+(char+*s)+++++++++//+trim+leading+and+trailing+spaces%2Btabs
{
+int+i,j,k,+len;

+j=k=0;
+len+=+strlen(s);
++++++++++++++++++++//+find+start+of+string
+for+(i=0;+i<len;+i%2B%2B)+if+((s[i]!=32)+&&+(s[i]!=9))+{+j=i;+break;+}
++++++++++++++++++++//+find+end+of+string%2B1
+for+(i=len-1;+i>=j;+i--)+if+((s[i]!=32)+&&+(s[i]!=9))+{+k=i%2B1;+break;}+

+if+(k<=j)+{s[0]=0;+return;}++++++++//+all+whitespace+(j==k==0)

+len=k-j;
+for+(i=0;+i<len;+i%2B%2B)+s[i]+=+s[j%2B%2B];+++//+shift+result+to+start+of+string
+s[i]=0;++++++++++++++++//+end+the+string

}//_trim|code-block|syntax|javascript|1532949|entityMap^0|1A|9|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

This one is short and simple, uses for-loops and doesn't overwrite the string boundaries.
You can replace the test with <code>isspace()</code> if needed.

<pre><code>void trim (char *s) // trim leading and trailing spaces+tabs
{
 int i,j,k, len;

 j=k=0;
 len = strlen(s);
 // find start of string
 for (i=0; i&lt;len; i++) if ((s[i]!=32) &amp;&amp; (s[i]!=9)) { j=i; break; }
 // find end of string+1
 for (i=len-1; i&gt;=j; i--) if ((s[i]!=32) &amp;&amp; (s[i]!=9)) { k=i+1; break;} 

 if (k&lt;=j) {s[0]=0; return;} // all whitespace (j==k==0)

 len=k-j;
 for (i=0; i&lt;len; i++) s[i] = s[j++]; // shift result to start of string
 s[i]=0; // end the string

}//_trim
</code></pre>

blocks|key|1747981|text|由于其他答案似乎没有直接改变字符串指针，而是依赖于返回值，我想我应该提供这个方法，它另外不使用任何库，因此适合于操作系统风格的编程：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1747982|//+only+used+for+printf+in+main
#include+<stdio.h>

//+note+the+char+**+means+we+can+modify+the+address
char+*trimws(char+**strp)+{+
++char+*str;
++//+check+if+empty+string
++if(!*str)
++++return;
++//+go+to+the+end+of+the+string
++for+(str+=+*strp;+*str;+str%2B%2B)+
++++;
++//+back+up+one+from+the+null+terminator
++str--;+
++//+set+trailing+ws+to+null
++for+(;+*str+==+'+';+str--)+
++++*str+=+0;
++//+increment+past+leading+ws
++for+(str+=+*strp;+*str+==+'+';+str%2B%2B)+
++++;
++//+set+new+begin+address+of+string
++*strp+=+str;+
}

int+main(void)+{
++char+buf[256]+=+"+++whitespace++++";
++//+pointer+must+be+modifiable+lvalue+so+we+make+bufp
++char+**bufp+=+&buf;
++//+pass+in+the+address
++trimws(&bufp);
++//+prints+:+XXXwhitespaceXXX
++printf("XXX%25sXXX\n",+bufp);+
++return+0;
}|code-block|syntax|javascript|1747983|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

As the other answers don't seem to mutate the string pointer directly, but rather rely on the return value, I thought I would provide this method which additionally does not use any libraries and so is appropriate for operating system style programming:
<pre><code>// only used for printf in main
#include &lt;stdio.h&gt;

// note the char ** means we can modify the address
char *trimws(char **strp) { 
 char *str;
 // check if empty string
 if(!*str)
 return;
 // go to the end of the string
 for (str = *strp; *str; str++) 
 ;
 // back up one from the null terminator
 str--; 
 // set trailing ws to null
 for (; *str == ' '; str--) 
 *str = 0;
 // increment past leading ws
 for (str = *strp; *str == ' '; str++) 
 ;
 // set new begin address of string
 *strp = str; 
}

int main(void) {
 char buf[256] = &quot; whitespace &quot;;
 // pointer must be modifiable lvalue so we make bufp
 char **bufp = &amp;buf;
 // pass in the address
 trimws(&amp;bufp);
 // prints : XXXwhitespaceXXX
 printf(&quot;XXX%sXXX\n&quot;, bufp); 
 return 0;
}
</code></pre>

blocks|key|1748004|text|没有strlen和isspace，也可以做到这一点。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1748005|char+*
trim+(char+*+s,+char+c)
{
++++unsigned+o+=+0;
++++char+*+sb+=+s;

++++for+(;+*s+==+c;+s%2B%2B)
++++++++o%2B%2B;

++++for+(;+*s+!=+'\0';+s%2B%2B)
++++++++continue;
++++for+(;+s+-+o+>+sb+&&+*--s+==+c;)
++++++++continue;

++++if+(o+>+0)
++++++++memmove(sb,+sb+%2B+o,+s+%2B+1+-+o+-+sb);
++++if+(*s+!=+'\0')
++++++++*(s+%2B+1+-+o)+=+'\0';

++++return+sb;
}|code-block|syntax|javascript|1748006|entityMap^0|2|6|9|7|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|L|$]]

IMO, it can be done without <code>strlen</code> and <code>isspace</code>.
<pre><code>char *
trim (char * s, char c)
{
 unsigned o = 0;
 char * sb = s;

 for (; *s == c; s++)
 o++;

 for (; *s != '\0'; s++)
 continue;
 for (; s - o &gt; sb &amp;&amp; *--s == c;)
 continue;

 if (o &gt; 0)
 memmove(sb, sb + o, s + 1 - o - sb);
 if (*s != '\0')
 *(s + 1 - o) = '\0';

 return sb;
}
</code></pre>

Is there a clean, preferably standard method of trimming leading and trailing whitespace from a string in C? I'd roll my own, but I would think this is a common problem with an equally common solution.

How do I trim leading/trailing whitespace in a standard way?

单元测试

Linux

在C中有没有一种干净的，最好是标准的方法来修剪字符串中的前导空格和尾随空格？我会使用我自己的，但我会认为这是一个常见的问题，有一个同样常见的解决方案。

问如何以标准的方式修剪前导/尾随空格？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何以标准的方式修剪前导/尾随空格？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何以标准的方式修剪前导/尾随空格？
EN