C 不改变原始字符串的字符串反转

所以这里似乎有太多的字符串反转问题，但我想做的具体问题似乎没有涉及。我这样做只是为了复习C语言，没有什么意义。我想要达到的标准

1.编写一个可以反转字符串的函数

2.不会更改原件

3.必须只接受原始字符串作为参数

4.不会使用现有的字符串反转函数

我最初编写了简单的代码来进行反转，但很难使其不改变原始代码。初始代码如下：

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


char *reverse(char *inString){
    int j = 0;
    j = strlen(inString) -1;
    char temp;
    for(int i = 0 ; i<=j; i++,j--){
        temp = inString[i];
        inString[i] = inString[j];
        inString[j] = temp;
    }
    return inString;
}


int main(){
    char string[20]="hello world";
    printf("%s\n",string);
    char *outString = reverse(string);
    printf("%s\n",string);
    printf("%s\n",outString);
}

---

string和outString引用内存中的同一个对象，即“helloworld”字符串数组，这就是为什么会得到相同的反向字符串

---

要么复制数组并反转副本，要么将字符串反转为其原始形式。

字符串和outString引用内存中的同一对象，即“hello world”字符串数组，这就是为什么会得到相同的反转字符串

---

要么复制数组并反转副本，要么将字符串反转为其原始形式。

您的问题是您确实在修改输入字符串，行中：

inString[i] = inString[j];

---

你不需要做这种事。只要设置输出字符串的第j个字符，在内存中分配适当的空间。

您的问题是您确实在修改输入字符串，行中：

inString[i] = inString[j];

你不需要做这种事。只要设置输出字符串的第j个字符，然后在内存中分配适当的空间。

我的建议：

为新字符串分配内存

填充包含输入字符串相反方向的新字符串

返回新字符串

确保在调用函数中释放新字符串的内存

比如：

char *reverse(char *inString)
{
   int len = strlen(inString);
   char* retString = malloc(len+1);
   if ( retString != NULL )
   {
      for(int i = 0 ; i < len; ++i)
      {
         retString[len-1-i] = inString[i];
      }
      retString[len] = '\0';
   }
   return retString;
}

char*反向（char*inString）
{
int len=strlen（inString）；
char*retString=malloc（len+1）；
if（retString！=NULL）
{
对于（int i=0；i

我的建议：

为新字符串分配内存

填充包含输入字符串相反方向的新字符串

返回新字符串

确保在调用函数中释放新字符串的内存

比如：

char *reverse(char *inString)
{
   int len = strlen(inString);
   char* retString = malloc(len+1);
   if ( retString != NULL )
   {
      for(int i = 0 ; i < len; ++i)
      {
         retString[len-1-i] = inString[i];
      }
      retString[len] = '\0';
   }
   return retString;
}

char*反向（char*inString）
{
int len=strlen（inString）；
char*retString=malloc（len+1）；
if（retString！=NULL）
{
对于（int i=0；i

这是一个演示程序，演示如何编写函数

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

char * reverse( const char *s )
{
    size_t n = strlen( s );

    char *t = malloc( ( n + 1 ) * sizeof( char ) );

    if ( t )
    {
        size_t i = 0;
        for ( ; i < n; i++ ) t[i] = s[n - i - 1];
        t[i] = '\0';
    }

    return t;
}

int main(void) 
{
    char *s = "Hello World";
    char *t = reverse( s );

    puts( s );
    puts( t );

    free( t );

    return 0;
}

---

正如您自己所见，您必须为反向字符串分配内存。

这里有一个演示程序，演示如何编写函数

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

char * reverse( const char *s )
{
    size_t n = strlen( s );

    char *t = malloc( ( n + 1 ) * sizeof( char ) );

    if ( t )
    {
        size_t i = 0;
        for ( ; i < n; i++ ) t[i] = s[n - i - 1];
        t[i] = '\0';
    }

    return t;
}

int main(void) 
{
    char *s = "Hello World";
    char *t = reverse( s );

    puts( s );
    puts( t );

    free( t );

    return 0;
}

---

正如您自己看到的，您必须为反转的字符串分配内存。

反转（strdup（string））

或

inString=strdup（inString）

在

reverse

@collone三十二：这太容易了（）：D；）哈哈，是的，肯定是太复杂了。也别忘了解开绳子。还添加

返回0main

的末尾添加

const

-->

char*reverse（const char*inString）

以确保

reverse

不会改变原始值。现在，

reverse（）

的主体需要更改。太。

reverse（strdup（string））

或

inString=strdup（inString）

在

reverse

@collone三十二：那太容易了（）：D；）哈哈，是的，肯定是太复杂了。也别忘了解开绳子。还添加

返回0main

的末尾添加

const

-->

char*reverse（const char*inString）

以确保

reverse

不会改变原始值。现在，

reverse（）

的主体需要更改。我也是。这正是我想要做的。也许我需要添加第五个标准并排除strdup（）。这实际上就是我想要做的。也许我需要添加第五个标准并排除strdup（）。太好了！（除了总是

*1

的

*sizeof（char）

）之外。太好了！（除了总是

*1

的

*sizeof（char）

）之外）。