blocks|key|1503126|text|#include+<algorithm>
std::reverse(str.begin(),+str.end());|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1503127|这是C%2B%2B中最简单的方法。|unstyled|1503128|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>#include &lt;algorithm&gt;
std::reverse(str.begin(), str.end());
</code></pre>

This is the simplest way in C++.

blocks|key|1503299|text|阅读Kernighan和Ritchie|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1503300|#include+<string.h>

void+reverse(char+s[])
{
++++int+length+=+strlen(s)+;
++++int+c,+i,+j;

++++for+(i+=+0,+j+=+length+-+1;+i+<+j;+i%2B%2B,+j--)
++++{
++++++++c+=+s[i];
++++++++s[i]+=+s[j];
++++++++s[j]+=+c;
++++}
}|code-block|syntax|javascript|1503301|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|$]]

Read Kernighan and Ritchie

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

void reverse(char s[])
{
 int length = strlen(s) ;
 int c, i, j;

 for (i = 0, j = length - 1; i &lt; j; i++, j--)
 {
 c = s[i];
 s[i] = s[j];
 s[j] = c;
 }
}
</code></pre>

blocks|key|1503194|text|非邪恶C，假设字符串是一个以null结尾的char数组的常见情况：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1503195|#include+<stddef.h>
#include+<string.h>

/*+PRE:+str+must+be+either+NULL+or+a+pointer+to+a+
+*+(possibly+empty)+null-terminated+string.+*/
void+strrev(char+*str)+{
++char+temp,+*end_ptr;

++/*+If+str+is+NULL+or+empty,+do+nothing+*/
++if(+str+==+NULL+%7C%7C+!(*str)+)
++++return;

++end_ptr+=+str+%2B+strlen(str)+-+1;

++/*+Swap+the+chars+*/
++while(+end_ptr+>+str+)+{
++++temp+=+*str;
++++*str+=+*end_ptr;
++++*end_ptr+=+temp;
++++str%2B%2B;
++++end_ptr--;
++}
}|code-block|syntax|javascript|1503196|entityMap^0|L|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|$]]

Non-evil C, assuming the common case where the string is a null-terminated <code>char</code> array:

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

/* PRE: str must be either NULL or a pointer to a 
 * (possibly empty) null-terminated string. */
void strrev(char *str) {
 char temp, *end_ptr;

 /* If str is NULL or empty, do nothing */
 if( str == NULL || !(*str) )
 return;

 end_ptr = str + strlen(str) - 1;

 /* Swap the chars */
 while( end_ptr &gt; str ) {
 temp = *str;
 *str = *end_ptr;
 *end_ptr = temp;
 str++;
 end_ptr--;
 }
}
</code></pre>

blocks|key|1718630|text|已经有一段时间了，我不记得是哪本书教会了我这个算法，但我觉得它很巧妙，很容易理解：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1718631|char+input[]+=+"moc.wolfrevokcats";

int+length+=+strlen(input);
int+last_pos+=+length-1;
for(int+i+=+0;+i+<+length/2;+i%2B%2B)
{
++++char+tmp+=+input[i];
++++input[i]+=+input[last_pos+-+i];
++++input[last_pos+-+i]+=+tmp;
}

printf("%25s\n",+input);|code-block|syntax|javascript|1718632|此算法的可视化，由slashdottir提供|offset|length|1718633|​|1718634|📷|atomic|1718635|1718636|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/users/901444/slashdottir|1|IMAGE|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/6d587c2a50d2e7ff9e7a964c6eafef19.gif|imageAlt^0|0|0|9|B|0|0|0|0|1|1|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|15|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|16|8|@]|9|@$I|17|J|18|1|19]]|A|$]]|$1|K|3|L|5|6|7|1A|8|@]|9|@]|A|$]]|$1|M|3|N|5|O|7|1B|8|@]|9|@$I|1C|J|1D|1|1E]]|A|$]]|$1|P|3|L|5|6|7|1F|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|1G|8|@]|9|@]|A|$]]]|R|$S|$5|T|U|V|A|$W|X]]|Y|$5|Z|U|10|A|$11|12|13|-4]]]]

It's been a while and I don't remember which book taught me this algorithm, but I thought it was quite ingenious and simple to understand:
<pre><code>char input[] = &quot;moc.wolfrevokcats&quot;;

int length = strlen(input);
int last_pos = length-1;
for(int i = 0; i &lt; length/2; i++)
{
 char tmp = input[i];
 input[i] = input[last_pos - i];
 input[last_pos - i] = tmp;
}

printf(&quot;%s\n&quot;, input);
</code></pre>
A visualization of this algorithm, courtesy of <a href="https://stackoverflow.com/users/901444/slashdottir">slashdottir</a>:
<img src="https://i.stack.imgur.com/LLSbH.gif" alt="Visualization of the algorithm to reverse a string in place" />

blocks|key|1503250|text|注意，std::reverse的美妙之处在于，它可以像处理std::string一样处理char+*字符串和std::wstring|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1503251|void+strrev(char+*str)
{
++++if+(str+==+NULL)
++++++++return;
++++std::reverse(str,+str+%2B+strlen(str));
}|code-block|syntax|javascript|1503252|entityMap^0|T|B|18|6|1I|C|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]|$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|U|8|@]|D|@]|E|$]]]|L|$]]

Note that the beauty of std::reverse is that it works with <code>char *</code> strings and <code>std::wstring</code>s just as well as <code>std::string</code>s

<pre><code>void strrev(char *str)
{
 if (str == NULL)
 return;
 std::reverse(str, str + strlen(str));
}
</code></pre>

blocks|key|1718820|text|另一种反向方式(尽管我自己可能会使用std：：C%2B%2B+()+:)，因为它更具表现力和更快)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1718821|str+=+std::string(str.rbegin(),+str.rend());|code-block|syntax|javascript|1718822|C方式(或多或少:)+)，请注意交换的XOR技巧，编译器有时无法优化它。|1718823|In+such+case+it+is+usually+much+slower.|offset|length|1718824|char*+reverse(char*+s)
{
++++char*+beg+=+s,+*end+=+s,+tmp;
++++while+(*end)+end%2B%2B;
++++while+(end--+>+beg)
++++{+
++++++++tmp++=+*beg;+
++++++++*beg%2B%2B+=+*end;++
++++++++*end+=++tmp;
++++}
++++return+s;
}+//+fixed:+check+history+for+details,+as+those+are+interesting+ones|1718825|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/XOR_swap_algorithm#Reasons_for_avoidance_in_practice^0|0|0|0|0|13|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|Z|8|@]|9|@$K|10|L|11|1|12]]|A|$]]|$1|M|3|N|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]]]

Another C++ way (though I would probably use std::reverse() myself :) as being more expressive and faster)

<pre><code>str = std::string(str.rbegin(), str.rend());
</code></pre>

The C way (more or less :) )
and please, be careful about XOR trick for swapping, 
compilers sometimes cannot optimize that.

<a href="http://en.wikipedia.org/wiki/XOR_swap_algorithm#Reasons_for_avoidance_in_practice" rel="nofollow noreferrer">In such case it is usually much slower.</a>

<pre><code>char* reverse(char* s)
{
 char* beg = s, *end = s, tmp;
 while (*end) end++;
 while (end-- &gt; beg)
 { 
 tmp = *beg; 
 *beg++ = *end; 
 *end = tmp;
 }
 return s;
} // fixed: check history for details, as those are interesting ones
</code></pre>

blocks|key|1503083|text|#include+<cstdio>
#include+<cstdlib>
#include+<string>

void+strrev(char+*str)
{
++++++++if(+str+==+NULL+)
++++++++++++++++return;

++++++++char+*end_ptr+=+&str[strlen(str)+-+1];
++++++++char+temp;
++++++++while(+end_ptr+>+str+)
++++++++{
++++++++++++++++temp+=+*str;
++++++++++++++++*str%2B%2B+=+*end_ptr;
++++++++++++++++*end_ptr--+=+temp;
++++++++}
}

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

++++++++strcpy(buffer,+"testing");
++++++++strrev(buffer);
++++++++printf("%25s\n",+buffer);

++++++++strcpy(buffer,+"a");
++++++++strrev(buffer);
++++++++printf("%25s\n",+buffer);

++++++++strcpy(buffer,+"abc");
++++++++strrev(buffer);
++++++++printf("%25s\n",+buffer);

++++++++strcpy(buffer,+"");
++++++++strrev(buffer);
++++++++printf("%25s\n",+buffer);

++++++++strrev(NULL);

++++++++return+0;
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1503084|此代码生成以下输出：|unstyled|1503085|gnitset
a
cba|1503086|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|L|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$B|C]]|$1|I|3|-4|5|F|7|N|8|@]|9|@]|A|$]]]|J|$]]

<pre><code>#include &lt;cstdio&gt;
#include &lt;cstdlib&gt;
#include &lt;string&gt;

void strrev(char *str)
{
 if( str == NULL )
 return;

 char *end_ptr = &amp;str[strlen(str) - 1];
 char temp;
 while( end_ptr &gt; str )
 {
 temp = *str;
 *str++ = *end_ptr;
 *end_ptr-- = temp;
 }
}

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

 strcpy(buffer, "testing");
 strrev(buffer);
 printf("%s\n", buffer);

 strcpy(buffer, "a");
 strrev(buffer);
 printf("%s\n", buffer);

 strcpy(buffer, "abc");
 strrev(buffer);
 printf("%s\n", buffer);

 strcpy(buffer, "");
 strrev(buffer);
 printf("%s\n", buffer);

 strrev(NULL);

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

This code produces this output:

<pre><code>gnitset
a
cba
</code></pre>

blocks|key|1503347|text|如果您使用的是GLib，它有两个函数：g_strreverse()和g_utf8_strreverse()|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1503348|entityMap|0|LINK|mutability|MUTABLE|url|http://library.gnome.org/devel/glib/stable/glib-String-Utility-Functions.html#g-strreverse|1|http://library.gnome.org/devel/glib/stable/glib-Unicode-Manipulation.html#g-utf8-strreverse^0|J|E|0|Y|J|1|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]|$A|R|B|S|1|T]]|C|$]]|$1|D|3|-4|5|6|7|U|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]|L|$5|G|H|I|C|$J|M]]]]

In case you are using GLib, it has two functions for that, <a href="http://library.gnome.org/devel/glib/stable/glib-String-Utility-Functions.html#g-strreverse" rel="nofollow noreferrer">g_strreverse()</a> and <a href="http://library.gnome.org/devel/glib/stable/glib-Unicode-Manipulation.html#g-utf8-strreverse" rel="nofollow noreferrer">g_utf8_strreverse()</a>

blocks|key|1718490|text|我喜欢叶夫根尼的K&R答案。然而，看到一个使用指针的版本是很好的。除此之外，它本质上是相同的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1718491|#include+<stdio.h>
#include+<string.h>
#include+<stdlib.h>

char+*reverse(char+*str)+{
++++if(+str+==+NULL+%7C%7C+!(*str)+)+return+NULL;
++++int+i,+j+=+strlen(str)-1;
++++char+*sallocd;
++++sallocd+=+malloc(sizeof(char)+*+(j%2B1));
++++for(i=0;+j>=0;+i%2B%2B,+j--)+{
++++++++*(sallocd%2Bi)+=+*(str%2Bj);
++++}
++++return+sallocd;
}

int+main(void)+{
++++char+*s+=+"a+man+a+plan+a+canal+panama";
++++char+*sret+=+reverse(s);
++++printf("%25s\n",+reverse(sret));
++++free(sret);
++++return+0;
}|code-block|syntax|javascript|1718492|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 like Evgeny's K&amp;R answer. However, it is nice to see a version using pointers. Otherwise, it's essentially the same:

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

char *reverse(char *str) {
 if( str == NULL || !(*str) ) return NULL;
 int i, j = strlen(str)-1;
 char *sallocd;
 sallocd = malloc(sizeof(char) * (j+1));
 for(i=0; j&gt;=0; i++, j--) {
 *(sallocd+i) = *(str+j);
 }
 return sallocd;
}

int main(void) {
 char *s = "a man a plan a canal panama";
 char *sret = reverse(s);
 printf("%s\n", reverse(sret));
 free(sret);
 return 0;
}
</code></pre>

blocks|key|1503580|text|用于就地反转字符串的递归函数(不需要额外的缓冲区，malloc)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1503581|简短，性感的代码。坏的，坏的堆栈使用。|1503582|#include+<stdio.h>

/*+Store+the+each+value+and+move+to+next+char+going+down
+*+the+stack.+Assign+value+to+start+ptr+and+increment+
+*+when+coming+back+up+the+stack+(return).
+*+Neat+code,+horrible+stack+usage.
+*
+*+val+-+value+of+current+pointer.
+*+s+-+start+pointer
+*+n+-+next+char+pointer+in+string.
+*/
char+*reverse_r(char+val,+char+*s,+char+*n)
{
++++if+(*n)
++++++++s+=+reverse_r(*n,+s,+n%2B1);
+++*s+=+val;
+++return+s%2B1;
}

/*
+*+expect+the+string+to+be+passed+as+argv[1]
+*/
int+main(int+argc,+char+*argv[])
{
++++char+*aString;

++++if+(argc+<+2)
++++{
++++++++printf("Usage:+RSIP+<string>\n");
++++++++return+0;
++++}

++++aString+=+argv[1];
++++printf("String+to+reverse:+%25s\n",+aString+);

++++reverse_r(*aString,+aString,+aString%2B1);+
++++printf("Reversed+String:+++%25s\n",+aString+);

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

Recursive function to reverse a string in place (no extra buffer, malloc).

Short, sexy code. Bad, bad stack usage. 

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

/* Store the each value and move to next char going down
 * the stack. Assign value to start ptr and increment 
 * when coming back up the stack (return).
 * Neat code, horrible stack usage.
 *
 * val - value of current pointer.
 * s - start pointer
 * n - next char pointer in string.
 */
char *reverse_r(char val, char *s, char *n)
{
 if (*n)
 s = reverse_r(*n, s, n+1);
 *s = val;
 return s+1;
}

/*
 * expect the string to be passed as argv[1]
 */
int main(int argc, char *argv[])
{
 char *aString;

 if (argc &lt; 2)
 {
 printf("Usage: RSIP &lt;string&gt;\n");
 return 0;
 }

 aString = argv[1];
 printf("String to reverse: %s\n", aString );

 reverse_r(*aString, aString, aString+1); 
 printf("Reversed String: %s\n", aString );

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

blocks|key|1718890|text|如果您使用的是ATL/MFC+CString，只需调用CString::MakeReverse()。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1718891|entityMap^0|F|7|R|M|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|M|8|@]|D|@]|E|$]]]|G|$]]

If you are using ATL/MFC <code>CString</code>, simply call <code>CString::MakeReverse()</code>.

blocks|key|1503631|text|还有另一个：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1503632|#include+<stdio.h>
#include+<strings.h>

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

++char+*reverse+=+argv[argc-1];
++char+*left+=+reverse;
++int+length+=+strlen(reverse);
++char+*right+=+reverse%2Blength-1;
++char+temp;

++while(right-left>=1){

++++temp=*left;
++++*left=*right;
++++*right=temp;
++++%2B%2Bleft;
++++--right;

++}

++printf("%25s\n",+reverse);

}|code-block|syntax|javascript|1503633|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|$]]

Yet another:

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

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

 char *reverse = argv[argc-1];
 char *left = reverse;
 int length = strlen(reverse);
 char *right = reverse+length-1;
 char temp;

 while(right-left&gt;=1){

 temp=*left;
 *left=*right;
 *right=temp;
 ++left;
 --right;

 }

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

}
</code></pre>

blocks|key|1503728|text|#include+<stdio.h>
#include+<stdlib.h>
#include+<string.h>
#include+<stdbool.h>

unsigned+char+*+utf8_reverse(const+unsigned+char+*,+int);
void+assert_true(bool);

int+main(void)
{
++++unsigned+char+str[]+=+"mañana+mañana";
++++unsigned+char+*ret+=+utf8_reverse(str,++strlen((const+char+*)+str)+%2B+1);

++++printf("%25s\n",+ret);
++++assert_true(0+==+strncmp((const+char+*)+ret,+"anãnam+anañam",+strlen("anãnam+anañam")+%2B+1));

++++free(ret);

++++return+EXIT_SUCCESS;
}

unsigned+char+*+utf8_reverse(const+unsigned+char+*str,+int+size)
{
++++unsigned+char+*ret+=+calloc(size,+sizeof(unsigned+char*));
++++int+ret_size+=+0;
++++int+pos+=+size+-+2;
++++int+char_size+=+0;

++++if+(str+==++NULL)+{
++++++++fprintf(stderr,+"failed+to+allocate+memory.\n");
++++++++exit(EXIT_FAILURE);
++++}

++++while+(pos+>+-1)+{

++++++++if+(str[pos]+<+0x80)+{
++++++++++++char_size+=+1;
++++++++}+else+if+(pos+>+0+&&+str[pos+-+1]+>+0xC1+&&+str[pos+-+1]+<+0xE0)+{
++++++++++++char_size+=+2;
++++++++}+else+if+(pos+>+1+&&+str[pos+-+2]+>+0xDF+&&+str[pos+-+2]+<+0xF0)+{
++++++++++++char_size+=+3;
++++++++}+else+if+(pos+>+2+&&+str[pos+-+3]+>+0xEF+&&+str[pos+-+3]+<+0xF5)+{
++++++++++++char_size+=+4;
++++++++}+else+{
++++++++++++char_size+=+1;
++++++++}

++++++++pos+-=+char_size;
++++++++memcpy(ret+%2B+ret_size,+str+%2B+pos+%2B+1,+char_size);
++++++++ret_size+%2B=+char_size;
++++}++++

++++ret[ret_size]+=+'\0';

++++return+ret;
}

void+assert_true(bool+boolean)
{
++++puts(boolean+==+true+?+"true"+:+"false");
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1503729|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;stdlib.h&gt;
#include &lt;string.h&gt;
#include &lt;stdbool.h&gt;

unsigned char * utf8_reverse(const unsigned char *, int);
void assert_true(bool);

int main(void)
{
 unsigned char str[] = "mañana mañana";
 unsigned char *ret = utf8_reverse(str, strlen((const char *) str) + 1);

 printf("%s\n", ret);
 assert_true(0 == strncmp((const char *) ret, "anãnam anañam", strlen("anãnam anañam") + 1));

 free(ret);

 return EXIT_SUCCESS;
}

unsigned char * utf8_reverse(const unsigned char *str, int size)
{
 unsigned char *ret = calloc(size, sizeof(unsigned char*));
 int ret_size = 0;
 int pos = size - 2;
 int char_size = 0;

 if (str == NULL) {
 fprintf(stderr, "failed to allocate memory.\n");
 exit(EXIT_FAILURE);
 }

 while (pos &gt; -1) {

 if (str[pos] &lt; 0x80) {
 char_size = 1;
 } else if (pos &gt; 0 &amp;&amp; str[pos - 1] &gt; 0xC1 &amp;&amp; str[pos - 1] &lt; 0xE0) {
 char_size = 2;
 } else if (pos &gt; 1 &amp;&amp; str[pos - 2] &gt; 0xDF &amp;&amp; str[pos - 2] &lt; 0xF0) {
 char_size = 3;
 } else if (pos &gt; 2 &amp;&amp; str[pos - 3] &gt; 0xEF &amp;&amp; str[pos - 3] &lt; 0xF5) {
 char_size = 4;
 } else {
 char_size = 1;
 }

 pos -= char_size;
 memcpy(ret + ret_size, str + pos + 1, char_size);
 ret_size += char_size;
 } 

 ret[ret_size] = '\0';

 return ret;
}

void assert_true(bool boolean)
{
 puts(boolean == true ? "true" : "false");
}
</code></pre>

blocks|key|1503888|text|C%2B%2B多字节UTF-8反向器|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1503889|我的想法是，您永远不能仅仅交换结尾，您必须始终从头到尾移动，遍历字符串并查找“此字符需要多少字节？”我从原始结束位置开始附加字符，并从字符串的前面删除该字符。|1503890|void+StringReverser(std::string+*original)
{
++int+eos+=+original->length()+-+1;
++while+(eos+>+0)+{
++++char+c+=+(*original)[0];
++++int+characterBytes;
++++switch(+(c+&+0xF0)+>>+4+)+{
++++case+0xC:
++++case+0xD:+/*+U%2B000080-U%2B0007FF:+two+bytes.+*/
++++++characterBytes+=+2;
++++++break;
++++case+0xE:+/*+U%2B000800-U%2B00FFFF:+three+bytes.+*/
++++++characterBytes+=+3;
++++++break;
++++case+0xF:+/*+U%2B010000-U%2B10FFFF:+four+bytes.+*/
++++++characterBytes+=+4;
++++++break;
++++default:
++++++characterBytes+=+1;
++++++break;
++++}

++++for+(int+i+=+0;+i+<+characterBytes;+i%2B%2B)+{
++++++original->insert(eos%2Bi,+1,+(*original)[i]);
++++}
++++original->erase(0,+characterBytes);
++++eos+-=+characterBytes;
++}
}|code-block|syntax|javascript|1503891|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

<h2>C++ multi-byte UTF-8 reverser</h2>
My thought is that you can never just swap ends, you must always move from beginning-to-end, move through the string and look for &quot;how many bytes will this character require?&quot; I attach the character starting at the original end position, and remove the character from the front of the string.
<pre><code>void StringReverser(std::string *original)
{
 int eos = original-&gt;length() - 1;
 while (eos &gt; 0) {
 char c = (*original)[0];
 int characterBytes;
 switch( (c &amp; 0xF0) &gt;&gt; 4 ) {
 case 0xC:
 case 0xD: /* U+000080-U+0007FF: two bytes. */
 characterBytes = 2;
 break;
 case 0xE: /* U+000800-U+00FFFF: three bytes. */
 characterBytes = 3;
 break;
 case 0xF: /* U+010000-U+10FFFF: four bytes. */
 characterBytes = 4;
 break;
 default:
 characterBytes = 1;
 break;
 }

 for (int i = 0; i &lt; characterBytes; i++) {
 original-&gt;insert(eos+i, 1, (*original)[i]);
 }
 original-&gt;erase(0, characterBytes);
 eos -= characterBytes;
 }
}
</code></pre>

blocks|key|1503909|text|void+reverseString(vector<char>&+s)+{
++++++++int+l+=+s.size();
++++++++char+ch+;
++++++++int+i+=+0+;
++++++++int+j+=+l-1;
++++++++while(i+<+j){
++++++++++++++++s[i]+=+s[i]%5Es[j];
++++++++++++++++s[j]+=+s[i]%5Es[j];
++++++++++++++++s[i]+=+s[i]%5Es[j];
++++++++++++++++i%2B%2B;
++++++++++++++++j--;
++++++++}
++++++++for(char+c+:+s)
++++++++++++++++cout+<<c+;
++++++++cout<<+endl;
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1503910|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 reverseString(vector&lt;char&gt;&amp; s) {
 int l = s.size();
 char ch ;
 int i = 0 ;
 int j = l-1;
 while(i &lt; j){
 s[i] = s[i]^s[j];
 s[j] = s[i]^s[j];
 s[i] = s[i]^s[j];
 i++;
 j--;
 }
 for(char c : s)
 cout &lt;&lt;c ;
 cout&lt;&lt; endl;
}
</code></pre>

blocks|key|1503947|text|在C%2B%2B中，可以在函数中执行相反的操作：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1503948|#include+<algorithm>
#include+<string>

void+backwards(vector<string>+&inputs_ref)+{
++++for+(auto+i+=+inputs_ref.begin();+i+!=+inputs_ref.end();+%2B%2Bi)+{
++++++++reverse(i->begin(),+i->end());
++++}
}|code-block|syntax|javascript|1503949|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|$]]

In C++ the reverse can be done in a function:
<pre><code>#include &lt;algorithm&gt;
#include &lt;string&gt;

void backwards(vector&lt;string&gt; &amp;inputs_ref) {
 for (auto i = inputs_ref.begin(); i != inputs_ref.end(); ++i) {
 reverse(i-&gt;begin(), i-&gt;end());
 }
}
</code></pre>

blocks|key|1503831|text|如果你不需要存储它，你可以像这样减少花费的时间：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1503832|void+showReverse(char+s[],+int+length)
{
++++printf("Reversed+String+without+storing+is+");
++++//could+use+another+variable+to+test+for+length,+keeping+length+whole.
++++//assumes+contiguous+memory
++++for+(;+length+>+0;+length--)
++++{
++++++++printf("%25c",+*(s%2B+length-1)+);
++++}
++++printf("\n");
}|code-block|syntax|javascript|1503833|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|$]]

If you don't need to store it, you can reduce the time spent like this:

<pre><code>void showReverse(char s[], int length)
{
 printf("Reversed String without storing is ");
 //could use another variable to test for length, keeping length whole.
 //assumes contiguous memory
 for (; length &gt; 0; length--)
 {
 printf("%c", *(s+ length-1) );
 }
 printf("\n");
}
</code></pre>

How do you reverse a string in C or C++ without requiring a separate buffer to hold the reversed string?

How do you reverse a string in place in C or C++?

编译器

如何在C或C++中反转字符串，而不需要单独的缓冲区来保存反转的字符串？

问如何在C或C++中就地反转字符串？
EN

回答 17

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在C或C++中就地反转字符串？EN

回答 17

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在C或C++中就地反转字符串？
EN