在C中反转字符串的帮助

我正在尝试反转C中的字符串

这是我有的

void reverse(char str[]) {
    int i = 0;

    int length;
    // Get string length
    for (i = 0; str[i] != '\0' ;   i) {
        length = i;
    }

    char reversed[1000];

    int j;
    j = 0;
    // Reverse it
    for (j = 0; j < length ;   j) {
        reversed[j] = str[length - j];
    }

}

我知道reversed包含字符串reversed,但我不知道如何在不丢弃所需数据的情况下修改原始str。

我也不知道如何设置strto反转而不再次循环。

再做一次可以接受吗...

    int m;
    m = 0;

    for (m = 0; m < length ;   m) {
        str[j] = reversed[j];
    }

通常我会说这么多循环很难闻，但我对这种语言还很不熟悉，所以我不确定...

更新

谢谢所有的答案，伙计们，我也很感激编辑！

我最终选择了这个...

int main() {

 char str[] = "Reverse me!";

 int length;

 for (length = 0; str[length] != '\0'; length  ) {

 }

 printf("length => %d chars\n", length);

 int j, k;
 char c;

 for (j = 0, k = length - 1; j < k; j  , k--) {
  c = str[k];    
  str[k] = str[j];
  str[j] = c;
 } 

 printf("reversed => %s\n", str);

 return 0;
}

有些事情我现在知道了...

在PHP中有一个strlen（）。但是，这本书还没有讨论过，加上我需要熟悉空终止字符串。 for循环可以分配和执行多个以逗号分隔的事情。我从来不知道这个！

所以询问是值得的:)

网友解决方案：

对代码的注释:

void reverse(char str[]) {
    int i = 0;

    int length;
    // Get string length
    for (i = 0; str[i] != '\0' ;   i) {
        length = i;
    }

与其每次都将i复制到长度，不如等到结尾。

size_t len = 0; // size_t is an unsigned integer that is large enough to hold the sizes
                // of the biggest things you can have (32 bits on 32 bit computer,
                // 64 bits on a 64 bit computer)
char * s = str;
while (*s) {
    len  ;
    s  ;
}

但是编译器可能能够为您进行此优化。

但是您应该知道，有一个标准字符串函数strlen(#include)，它将使用相同的通用算法（查找结尾）来测量char字符串的长度，但通常针对目标处理器进行了优化。

len = strlen(str);

再次使用您的代码:

    char reversed[1000];

使用大数组有利于学习和简单的示例，但您也可以根据您现在知道的所需大小动态分配内存。执行此操作的标准函数是malloc，它位于stdlib.h（也位于malloc.h）中。不过，也应该释放与此函数分配的内存。

int * p = malloc( 8 * sizeof(int) ); // allocate an array of 8 ints
/* ... work on p ... */
free(p);
/* ... don't access the memory pointed to by p anymore ... */
p = 0;

malloc家族中还有其他功能。还有calloc，它分配内存并清除将其设置为0。还有一个名为strdup的函数（在标准C中没有，但在string.h中非常可用），它接受一个字符串并分配它的副本。它真的只是:

char * strdup(const char * str) {
    size_t len = strlen(str);
    char * s = malloc(len 1);
    if (!s) {
        return s;
    }
    return strcpy(s,str); // This could have been memcpy since you know the size
                          // and memcpy might have been faster on many processors
}

另一个有用的内存分配函数是alloca（不在C标准中，但广泛可用，C99中的可变长度数组也有类似的功能）。它很棒，但与Malloc的工作方式不同。它分配仅在当前函数返回之前可用的内存，因为该内存的分配方式与本地变量（来自堆栈）的内存相同。

更多代码:

    int j;
    j = 0;
    // Reverse it
    for (j = 0; j < length ;   j) {
        reversed[j] = str[length - j];
    }

void reverse_in_place(char * str, size_t len) {
   size_t i, j;
   for (i = 0, j = len - 1; i < j ; i  , j--) {
        char a = str[i];
        char z = str[j];
        str[i] = z;
        str[j] = a;
   }
}