strcpy（char*，chara[]）给出的输出不正确。（逐字颠倒字符串）

Question

我想达到的目标是-

输入:(假定为字符串文字。)< code >这是一个字符串

输出：字符串 a 是这个

我天真的解决方案:

>

将字符串文本复制到char数组
char数组str[sizeofstring]的当前内容：这是一个字符串

逐字反转数组并将其存储在另一个数组中
char reverse[sizeofstring]：sihT si a gnirts

从最后一个位置反向遍历数组到第0个位置。将其存储在char数组解决方案中。
char解决方案[sizeofstring]：string a is this

strcpy（pointertoachar， solution）。- 因为函数需要返回指向字符的指针。

代码：

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

char *reverse(char *input) {
    int n = strlen(input);
    char str[n];

    char reverse[n];
    char solution[n];

    char *solutionp = malloc(sizeof(char) * n);
    strcpy(str, input);

    int last = 0;
    int i = 0;
    int q = 0;

    while (str[i] != '\0') {
        if (str[i] == ' ') {
            printf("i : %d\n", i);
            printf("LAST:%d\n", last);
            for (int t = (i - 1); t >= last; t--) { 
                reverse[q] = str[t];
                q++;
            }
            last = i + 1;
            reverse[q] = ' ';
            q++;
        }
        i++;
    }

    // for the last word.
    for (int cc = i - 1; cc >= last; cc--) {
        reverse[q] = str[cc];
        q++;
    }

    // Traversing from the last index to the first.
    int ii;
    int bb = 0;
    for (ii = n - 1; ii >= 0; ii--) {
        solution[bb] = reverse[ii];
        bb++;
    }

    // This prints the right output.
    // printf("%s\n",solution);

    // Copying from a char array to pointer pointing to a char array.
    strcpy(solutionp, solution);

    return solutionp;
}

int main() {
    char *str = "This is a string";
    char *answer;

    answer = reverse(str);
    printf("%s\n", answer);

    printf("\n");

    return 0;
}

问题：

步骤1到3按预期工作。出于调试目的，我尝试打印包含解决方案的数组的输出，并且它工作正常，但是当我使用< code>strcpy将它复制到由指针指向的char数组并返回指针时，它打印垃圾值以及部分正确的输出。< br >

输出：
字符串a是This？？Z

第4步似乎有些问题。我做错了什么？

Answer 1

代码中的主要问题是您将临时缓冲区分配得太短了一个字节。您必须为字符串末尾的最后一个'\0'字节腾出足够的空间。

您可以通过使用辅助函数以相反的顺序复制块来简化代码：

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

char *reverse_block(char *dest, const char *src, int len) {
    for (int i = 0; i < len; i++) {
        dest[i] = src[len - i - 1];
    }
    dest[len] = '\0';
    return dest;
}

char *reverse_words(const char *string) {
    int i, last;
    int len = strlen(string);
    char temp[len + 1];

    for (i = last = 0; i < len; i++) {
        if (string[i] == ' ') {
            // copy the word in reverse
            reverse_block(temp + last, string + last, i - last);
            temp[i] = ' ';
            last = i + 1;
        }
    }

    // copy the last word in reverse
    reverse_block(temp + last, string + last, len - last);

    // allocate an array, reverse the temp array into it and return it.
    return reverse_block(malloc(len + 1), temp, len);
}

int main(void) {
    const char *string = "This is a string";

    printf("%s\n", string);

    char *solution = reverse_words(string);
    printf("%s\n", solution);

    free(solution);

    return 0;
}

现在，您可以通过实现一个就地反转块的函数来进一步改进代码。有了这个，你不再需要临时缓冲区，你可以直接处理字符串副本，它简化了代码。