Question

我正在尝试反转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包含反转的字符串，但我不确定如何修改原始str而不丢弃我需要的数据。

我还不知道如何在不再循环的情况下将str设置为reversed 。

再做一次是否可以接受......

    int m;
    m = 0;

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

通常我会说这很多循环闻起来，但我还是对语言还不太熟悉所以我不确定......

更新

感谢所有答案的人，我也很感谢编辑！

我最终选择this ...

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循环可以分配和执行以逗号分隔的多个内容。我从来不知道这个！

所以要求值得：）

Answer 1

您想要进行就地撤消。这是一个标准算法：

// taken from The C Programming Language
//    by Brian Kernighan and Dennis Ritchie (K&R)
void reverse(char s[])
{
      int c, i, j;

      for (i = 0, j = strlen(s)-1; i < j; i++, j--) {
         c = s[i];
         s[i] = s[j];
         s[j] = c;
      }
}

请注意，strlen几乎取代了原来的第一个循环。它是string.h提供的众多标准字符串操作例程之一。

另见

Answer 2

您可以使用以下两种方法中的任何一种，具体取决于您是否对指针感到满意。当你学习指针时，也可以并排查看它们，这样你就可以更好地理解它们如何相互映射。

这是一个用于测试目的的完整程序：

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

// The pointer version.
void reverse1 (char *str) {
    char t;                      // Temporary char for swapping.
    char *s = str;               // First character of string.
    char *e = &(s[strlen(s)-1]); // Last character of string.

    // Swap first and last character the move both pointers
    // towards each other. Stop when they meet or cross.
    while (s < e) {
        t = *s;
        *s++ = *e;
        *e-- = t;
    }
}

// The array version.
void reverse2 (char *str) {
    char t;                // Temporary char for swapping.
    int s = 0;             // First character of string.
    int e = strlen(str)-1; // Last character of string.

    // Swap first and last character the move both pointers
    // towards each other. Stop when they meet or cross.
    while (s < e) {
        t = str[s];
        str[s++] = str[e];
        str[e--] = t;
    }
}

int main (void) {
    char x[] = "This is a string for reversing.";
    printf ("Original: [%s]\n", x);
    reverse1 (x);
    printf ("Reversed: [%s]\n", x);
    reverse2 (x);
    printf ("   Again: [%s]\n", x);
    return 0;
}

，输出为：

Original: [This is a string for reversing.]
Reversed: [.gnisrever rof gnirts a si sihT]
   Again: [This is a string for reversing.]

Answer 3

对您的代码的评论：

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 <string.h>），它将使用相同的通用算法测量字符串的长度（查找结尾），但是通常针对目标处理器进行优化。

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中非常广泛使用） string并分配它的副本。它真的只是：

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;
   }
}

应交换字符串的顺序而不复制它。对于奇数长度的字符串，它不会尝试将中间字符与自身交换。

Answer 4

使用指针反转C中的字符串

#include<stdio.h>
char *srcptr = "Hello!";
char *destptr;
unsigned int length = 0;
void main(void)
{
   while(*(ptr++) != '\0')
   {
       length++;
   }
   //at the end of while loop, pointer points to end of string 
   while(length--)
   {
        *destptr++ = *ptr--;
   }
    //append null at the end
    *destptr = '\0';
    printf("%s",ptr);
 }

帮助在C中反转字符串

更新

4 个答案:

另见