三种字符串逆序

第一种添加一个字符数组：

#include <stdio.h>  
#include <stdlib.h>  
#include <string.h>  

int main()  
{  
    int i;  
    int n;  
    char *q = "I am a coder";  
    n = strlen(q);  
    char buffer[n+1];//多一个位置放'\0'  
    printf("The string is:%s\n",q);  
    for( i = 0;i < n;i++)  
    {  
        buffer[n-1-i]=*q++;  
    }  
    buffer[n]='\0';  
    printf("The ending string is:%s\n",buffer);  
    return 0;  
}  

注意q是指向字符常量的指针，他指向的内容不能变，但是他自己可以变，所以能自加。

第二种是两个指针：

#include <stdio.h>  
#include <stdlib.h>  
#include <string.h>  

char *change(char *s)
{
    char *m = s;
    char *n = s;
    while(*(n+1))
        n++;    //将n指向字符串的最后一个字符。
    while(m<n)
    {
        char t = *m;
        *m++ = *n;
        *n-- = t;
    }
    return s;

}
int main()  
{  
    char q[] = "I am a coder";  //不能用指针申明为字符串常量。
    q = change(q);

    printf("The ending string is:%s\n",q);  
    return 0;  
}  

这里我真是执掌，把数组q用来接收函数返回的字符串，但是数组名是一个指针常量，是不能更改的，所以不能这样用，必须得重新申明一个指针来接收这个字符串。
char *str = change(q);

第三种是不用临时变量来交换他们，我知道的就只能用抑或了：

#include <stdio.h>  
#include <stdlib.h>  
#include <string.h>  

char *change(char *s)
{
    char *m = s;
    char *n = s;
    while(*(n+1))
        n++;    //将n指向字符串的最后一个字符。
    while(m<n)
    {
        *m = *m ^ *n;
        *n = *m ^ *n;
        *m = *m++ ^ *n--;
    }
    retrun s;

}
int main()  
{  
    char q[] = "I am a coder";  //不能用指针申明为字符串常量。
    char *str = change(q);

    printf("The ending string is:%s\n",str);  
    return 0;  
}  

感觉还是有点神奇的，这主要是抑或运算的性质来的：

1> 一个数抑或它本身结果是0。
2> 一个数抑或0结果是它本身。

然后根据这个性质就可以推算出来，我们要得到的无非是 a = b ；b = a ；

a = a ^ b ;
b = a ^ b; (这里的a 是上面变了的 a，代入 b = (a ^ b) ^ b; 展开 b = a ^ (b ^ b) ===> b = a ^ 0 ===> b = a ; )
a = a ^ b; ( 这里的a 和 b 都是上面变了的 a 和 b ，代入 a = （a ^ b) ^ a ===> a = b; )

交换完成。