如何在C中修改字符串

我是C语言的新手，我正在尝试对我拥有的字符串进行修改（我正在尝试反转它），但我不确定为什么程序不能按预期运行（没有显示输出）

void reverse（char*rTarget）；
int main（）
{
char memes[]=“memes”；
相反（模因）；
printf（“%s”，模因）；
}
无效反向（字符*rTarget）
{
字符交换；
int length=（int）strlen（rTarget）；
对于（int i=0；i

这应该可以做到：

void reverse(char rTarget[]);

int main()
{
    char memes[] = "memes";
    reverse(memes);
    printf("%s", memes);
}

void reverse(char rTarget[])
{
    char swap;
    int lastindex = (int) strlen(rTarget) - 1;

    for (int i = 0; i < lastindex / 2; i++)
    {
        swap = rTarget[i];
        rTarget[i] = rTarget[lastindex - i];
        rTarget[lastindex - i] = swap;
    }
}

void reverse（char rTarget[]）；
int main（）
{
char memes[]=“memes”；
相反（模因）；
printf（“%s”，模因）；
}
无效反向（字符目标[]）
{
字符交换；
int lastindex=（int）strlen（rTarget）-1；
对于（int i=0；i

您的代码中有几个问题。 首先，数组总是“通过引用传递”，所以不需要传递指向数组的指针。在数组中所做的任何更改都将在函数调用后保持不变。 其次，C中的数组下标从0开始。因此长度

n

的字符串中的最后一个字符（不算空）是

string[n-1]

not

string[n]

---

编辑：正如@rootTraveler所提到的，因为您正在交换字符，所以不需要一直运行到字符串的末尾。您只需要走到长度的一半。

对于初学者，此函数声明

void reverse(char *rTarget[]);

int length = (int) strlen(*rTarget);

相当于

void reverse(char **rTarget);

以这种方式宣布这一点是没有意义的

您应该像这样声明函数

void reverse( char rTarget[] );

就这样说吧

reverse( memes );

函数定义也是错误的。至少你必须像这样使用循环

for (int i = 0; i < length / 2; i++)

无效。它们将被改写为

    swap = ( *rTarget )[i];
    ( *rTarget )[i] = ( *rTarget )[length - i -1];
    ( *rTarget )[length - i - 1] = swap;

变量

length

的类型应为

size\u t

，因为通常int类型的对象不能容纳size\u t类型的对象，而函数

strlen

的返回类型为

size\u t

。所以你必须用这个声明来代替

void reverse(char *rTarget[]);

int length = (int) strlen(*rTarget);

对于这个声明

size_t length = strlen(*rTarget);

注意，根据标准C字符串函数的约定，函数应该返回指向反向字符串的指针

根据C标准，无参数的主要功能应声明如下

int main( void )

下面是一个演示程序，演示如何声明和定义函数

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

char * reverse( char *s )
{
    for ( size_t i = 0, n = strlen( s ); i < n / 2; i++ )
    {
        char c = s[i];
        s[i] = s[n-i-1];
        s[n-i-1] = c;
    }

    return s;
}

int main(void) 
{
    char memes[] = "memes";

    puts( reverse( memes ) );

    return 0;
}

---

这里有各种各样的解引用错误。请记住，字符串是字符数组，而不是字符指针数组。那么这个

void reverse(char *rTarget[])

应该是

void reverse(char rTarget[])

在这里：

int length = (int) strlen(*rTarget);

您不必取消引用

rTarget

，因此请删除

*

。同样，在交换中，删除所有的

*

最后但并非最不重要的一点是，在您的交换中存在一个逐个关闭的错误。不要转到

length-i

，而要转到

length-i-1

，否则将把空终止符换到开头

此外，循环应该只转到数组的前半部分，否则将交换所有内容两次，从而再次生成原始字符串：

for (int i = 0; i < length/2; i++)

for（int i=0；i

总而言之，它应该是这样的：

void reverse(char rTarget[]);

int main()
{
    char memes[] = "memes";
    reverse(memes);
    printf("%s", memes);
}

void reverse(char rTarget[])
{
    char swap;
    int length = (int)strlen(rTarget);

    for (int i = 0; i < length/2; i++)
    {
        swap = rTarget[i];
        rTarget[i] = rTarget[length - i - 1];
        rTarget[length - i - 1] = swap;
    }
}

void reverse（char rTarget[]）；
int main（）
{
char memes[]=“memes”；
相反（模因）；
printf（“%s”，模因）；
}
无效反向（字符目标[]）
{
字符交换；
int length=（int）strlen（rTarget）；
对于（int i=0；i

问题就在这里

*rTarget[i] = *rTarget[length - i]
*rTarget[length - i] = swap;

主要问题似乎是运算符优先级<代码>[]的优先级高于

*

。您正在传递“字符串数组”（因为指针可以用作数组），因此当

i

为0时，在左侧，您在

[0]

处获取第一个（也是唯一存在的）数组，并且

*

引用其第一个字符。对于这一点，您从右侧指定了无意义：数组的第一个字符

[length]

（它不存在），这是未定义的行为，因此在此之后您的程序所做的操作没有意义。您需要添加括号，以便引用指向数组的指针，从而获得实际数组，然后在该数组上使用

[]

但即使添加括号，您的算法也是错误的。在第一轮中，

i

为0，所以将

（*rTarget）[length]

复制到字符串的开头。这是以0结尾的字符串，因此您以修改后的字符串长度0结束（第一个字节为0）。长度需要-1

修复原始代码后，它将变为：

for（int i=0；i

---

---

此外，函数参数不必要地复杂（指向char的指针），直接指向可修改字符串就足够了。其他答案涵盖了这个美容问题

若不打算将多个字符串发送到反向函数，则函数参数只需要一个表示为“char a[]”的char指针。交换字符时，只需遍历字符串的50%。代码可以如下所示

void reverse(char a[]);

int main()
{
    char memes[] = "memes";
    reverse(memes);
    printf("%s", memes);
}

void reverse(char a[])
{
    char swap;
    int length = (int) strlen(a);
    for(int i = 0, j = (length - 1); i < (length / 2); i++, j--)
    {
        swap = a[i];
        a[i] = a[j];
        a[j] = swap;
    }
}

void reverse（字符a[]）；
int main（）
{
char memes[]=“memes”；
相反（模因）；
printf（“%s”，模因）；
}
无效反向（字符a[]）
{
字符交换；
int长度=（int）strlen（a）；
对于（int i=0，j=（长度-1）；i<（长度/2）；i++，j--）
{
swap=a[i]；
a[i]=a[j]；
a[j]=互换；
}
}

#包括
#包括
无效反向（char*rTarget）；
int main（）
{
char memes[]=“memes”；
相反（模因）；
printf（“%s”，模因）；
}
void reverse(char a[]);

int main()
{
    char memes[] = "memes";
    reverse(memes);
    printf("%s", memes);
}

void reverse(char a[])
{
    char swap;
    int length = (int) strlen(a);
    for(int i = 0, j = (length - 1); i < (length / 2); i++, j--)
    {
        swap = a[i];
        a[i] = a[j];
        a[j] = swap;
    }
}

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

void reverse(char *rTarget);

int main()
{
    char memes[] = "memes";
    reverse(memes);
    printf("%s", memes);
}

void reverse(char *rTarget)
{
    int length = (int) strlen(rTarget);

    for (int i = 0; i < length / 2; i++)
    {
        char swap = rTarget[i];
        rTarget[i] = rTarget[length - i - 1];
        rTarget[length - i - 1] = swap;
    }
}