цикл для переворота строки в C

Вы объявляете свой line массив на char короче, помните null в конце.

Другой момент, это должно быть for (x = strlen(string) - 1; x >= 0; x--), так как вам нужно скопировать символ в 0.

void reverse (char string[]) {
    int x;
    int i = 0;
    char line[strlen(string) + 1];

    for (x = strlen(string) - 1; x >= 0; x--) {
        char tmp = string[x];
        line[i] = tmp;
        i++;
    }

    for(x = 0; x < strlen(string); x++)
    {
        string[x] = line[x];
    }
}

Обратите внимание, что эта функция вызовет апокалипсис при передаче пустой строки или строкового литерала (как сказал Бобби Сакамано).

Предложение, которое вы, вероятно, можете сделать: void reverse(char source[], char[] dest) и проверить, пуста ли исходная строка.

Я думаю, что ваш ответ почти правильный. На самом деле вам не нужен дополнительный слот для нулевого символа в строке. Вам просто нужно два небольших изменения:

• Измените оператор присваивания внизу процедуры на memcpy.
• Измените условие цикла на ‹-

Итак, ваш правильный код:

void reverse (char string[]) {
  int x;
  int i = 0;
  char line[strlen(string)];

  for (x = strlen(string) - 1; x >= 0; x--) {
    char tmp = string[x];
    line[i] = tmp;
    i++;
  }
  memcpy(string, line, sizeof(char) * strlen(line));
}

Поскольку вы хотите перевернуть строку, вы сначала должны решить, хотите ли вы перевернуть копию строки или перевернуть строку на месте (на месте). Поскольку вы спросили об этом в контексте «C», предположим, что вы хотите изменить существующую строку (перевернуть существующую строку) и сделать копию строки в вызывающей функции, если вы хотите сохранить оригинал.

Вам понадобится строковая библиотека

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

Индексирование массивов работает, и эта версия использует этот подход,

/* this first version uses array indexing */
char*
streverse_a(char string[])
{
    int len; /*how big is your string*/
    int ndx; /*because 'i' is hard to search for*/
    char tmp; /*hold character to swap*/
    if(!string) return(string); /*avoid NULL*/
    if( (len=strlen(string)) < 2 ) return(string); /*one and done*/
    for( ndx=0; ndx<len/2; ndx++ ) {
        tmp=string[ndx];
        string[ndx]=string[len-1-ndx];
        string[len-1-ndx]=tmp;
    }
    return(string);
}

Но вы можете сделать то же самое с указателями,

/* this is how K&R would write the function with pointers */
char*
streverse(char* sp)
{
    int len, ndx; /*how big is your string */
    char tmp, *bp, *ep; /*pointers to begin/end, swap temporary*/
    if(!sp) return(sp); /*avoid NULL*/
    if( (len=strlen(bp=sp)) < 2 ) return(sp); /*one and done*/
    for( ep=bp+len-1; bp<ep; bp++, ep-- ) {
        tmp=*bp; *bp=*ep; *ep=tmp; /*swap*/
    }
    return(sp);
}

(Нет, действительно, компилятор не взимает меньше за возврат void.)

И поскольку вы всегда тестируете свой код,

char s[][100] = {
    "", "A", "AB", "ABC", "ABCD", "ABCDE",
    "hello, world", "goodbye, cruel world", "pwnz0r3d", "enough"
};

int
main()
{
    /* suppose your string is declared as 'a' */
    char a[100];
    strcpy(a,"reverse string");

    /*make a copy of 'a', declared the same as a[]*/
    char b[100];
    strcpy(b,a);
    streverse_a(b);
    printf("a:%s, r:%s\n",a,b);

    /*duplicate 'a'*/
    char *rp = strdup(a);
    streverse(rp);
    printf("a:%s, r:%s\n",a,rp);
    free(rp);

    int ndx;
    for( ndx=0; ndx<10; ++ndx ) {
        /*make a copy of 's', declared the same as s[]*/
        char b[100];
        strcpy(b,s[ndx]);
        streverse_a(b);
        printf("s:%s, r:%s\n",s[ndx],b);

        /*duplicate 's'*/
        char *rp = strdup(s[ndx]);
        streverse(rp);
        printf("s:%s, r:%s\n",s[ndx],rp);
        free(rp);
    }
}

Последняя строка в вашем коде ничего не делает string = line;

Параметры передаются по значению, поэтому, если вы измените их значение, оно будет локальным только для функции. Указатели - это значение адреса памяти, на которую они указывают. Если вы хотите изменить указатель, которому была передана функция, вам нужно взять указатель на этот указатель.

Вот краткий пример того, как вы могли бы это сделать.

void reverse (char **string) {
    char line = malloc(strlen(*string) + 1);
    //automatic arrays are deallocated once the function ends
    //so line needs to be dynamically or statically allocated

   // do something to line

    *string = line;
}

Очевидная проблема заключается в том, что вы можете инициализировать строку со статической памятью, тогда этот метод заменит статическую память динамической памятью, а затем вам придется освободить динамическую память. В этом нет ничего функционально неправильного, просто это немного опасно, поскольку случайное освобождение строкового литерала является незаконным.

char *test = "hello";
reverse(test);
free(test); //this is pretty scary

Кроме того, если тест был выделен как динамическая память, указатель на него был бы потерян, и тогда это стало бы утечкой памяти.