字符串逆序输出问题

dysow

函数接口定义：
void f( char *p );
函数f对p指向的字符串进行逆序操作。要求函数f中不能定义任何数组，不能调用任何字符串处理函数。

1. #include <stdlib.h>
   
2. void f( char *p )
   
3. {
   
4.     int i = 0;
   
5.     char *a;
   
6.     while (*p != '\0')
   
7.     {
   
8.         i ++;
   
9.         p ++;
   
10.     }
    
11.     a = (char *)malloc(i);
    
12.    
    
13.     int m = 0;
    
14.     int t = 0;
    
15.    
    
16.     p = p-i;
    
17.     for (m = i-1;m >= 0; m--)
    
18.     {
    
19.         a[t] = p[m];
    
20.         t ++;
    
21.     }
    
22.     a[t] = '\0';
    
23.     p = a;
    
24. }

复制代码

如上代码，在dev-c++里可以正常执行，在PTA那个平台里就不行，不知是哪里问题

C4rB0n

humm，感觉你这个方法转换不了啊，我在本机上进行测试了一下，也不行。
你可以试试这个代码，正好符合你的要求

1. void f(char* s) {
   
2.     // p指向字符串头部
   
3.     char* p = s ;
   
4. 
   
5.     // q指向字符串尾部
   
6.     char* q = s ;
   
7.     while( *q )
   
8.         ++q ;
   
9.     q -- ;
   
10. 
    
11.     // 交换并移动指针，直到p和q交叉
    
12.     while(q > p) {
    
13.         char t = *p ;
    
14.         *p++ = *q ;
    
15.         *q-- = t ;
    
16.     }
    
17. }

复制代码

然后你的第11行的代码应该是算创建了数组的把。

jackz007

1. void f(char * p)
   
2. {
   
3.         int c , i , n                    ;
   
4.         for(n = 0 ; p[n] ; n ++)         ;
   
5.         for(i = 0 ; i < n / 2 ; i ++) {
   
6.                 c = p[i]                 ;
   
7.                 p[i] = p[n - i - 1]      ;
   
8.                 p[n - i - 1] = c         ;
   
9.         }
   
10. }

复制代码

一叶枫残

我知道你那个问题在哪了：
首先，传入的是一个指针（字符串名就是一个指针，储存的是地址值），因为函数是值传递，它给的是那个地址值，不是那个指针，你只能修改这个地址值的解引用也就是值，你在函数修改其地址值并不对main里面的s的地址值产生任何影响，看下面代码就清楚了

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #define MAXS 20
   
4. 
   
5. void f( char *p );
   
6. void ReadString( char *s ); /* 由裁判实现，略去不表 */
   
7. 
   
8. int main()
   
9. {
   
10.         char s[MAXS];
    
11.         printf("主函数里：");
    
12.         printf("开始时s的地址:%x\n",s);
    
13.         printf("请输入字符串：");
    
14.         gets(s);
    
15.         f(s);
    
16.         printf("主函数里：调用函数后s的地址：%x\n", s);
    
17. 
    
18.         return 0;
    
19. }
    
20. 
    
21. /* 你的代码将被嵌在这里 */
    
22. void f( char *p )
    
23. {
    
24.         printf("\n函数f里：\n开始时p的地址：%x\n",p);
    
25.         int i = 0;
    
26.         char *a;
    
27.         printf("开始时a的地址：%x\n",a);
    
28.         while (*p != '\0')
    
29.             {
    
30.                 i ++;
    
31.                 p ++;
    
32.             }
    
33. 
    
34.             a = (char *)malloc(i);
    
35.             printf("分配内存后时a的地址：%x\n",a);
    
36.             int m = 0;
    
37.             int t = 0;
    
38.    
    
39.             p = p-i;
    
40.             for (m = i-1;m >= 0; m--)
    
41.             {
    
42.                 a[t] = p[m];
    
43.                        t ++;
    
44.             }
    
45.             a[t] ='\0';
    
46.             p = a;
    
47.             printf("结束后p的地址：%x\n",p);
    
48.             printf("结束后a的地址：%x\n\n",a);
    
49. }

复制代码

1. 主函数里：开始时s的地址:62fe00
   
2. 请输入字符串：abcd
   
3. 
   
4. 函数f里：
   
5. 开始时p的地址：62fe00
   
6. 开始时a的地址：62fd70
   
7. 分配内存后时a的地址：986ad0
   
8. 结束后p的地址：986ad0
   
9. 结束后a的地址：986ad0
   
10. 
    
11. 主函数里：调用函数后s的地址：62fe00

复制代码

你看地址都没有改变，怎么可能实现，还有的是，在PTA里没给出#include<stdlib.h>，意味着你不能使用malloc，一开始出发思路就错了，其实正确做法是调换值，例如字符串是abcd，a和d调换，b和c调换，就变成了dcba了，这个是可以实现的，因为地址值不能改变，但是其解引用后的值可以改变