strcat 将垃圾添加到字符串中

Question

我正在尝试颠倒一个句子，而不改变单词的顺序，

例如：“Hello World”=>“olleH dlroW”

这是我的代码：

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

char * reverseWords(const char *text);
char * reverseWord(char *word);

int main () {
  char *text = "Hello World";
  char *result = reverseWords(text);
  char *expected_result = "olleH dlroW";
  printf("%s == %s\n", result, expected_result);
  printf("%d\n", strcmp(result, expected_result));
  return 0;
}

char *
reverseWords (const char *text) {
  // This function takes a string and reverses it words.
  int i, j;
  size_t len = strlen(text);
  size_t text_size = len * sizeof(char);
  // output containst the output or the result
  char *output;

  // temp_word is a temporary variable,
  // it contains each word and it will be
  // empty after each space.
  char *temp_word;

  // temp_char is a temporary variable,
  // it contains the current character
  // within the for loop below.
  char temp_char;

  // allocating memory for output.
  output = (char *) malloc (text_size + 1);

  for(i = 0; i < len; i++) {

    // if the text[i] is space, just append it
    if (text[i] == ' ') {
      output[i] = ' ';
    }

    // if the text[i] is NULL, just get out of the loop
    if (text[i] == '\0') {
      break;
    }

    // allocate memory for the temp_word
    temp_word = (char *) malloc (text_size + 1);

    // set j to 0, so we can iterate only on the word
    j = 0;

    // while text[i + j] is not space or NULL, continue the loop
    while((text[i + j] != ' ') && (text[i + j] != '\0')) {

      // assign and cast test[i+j] to temp_char as a character,
      // (it reads it as string by default)
      temp_char = (char) text[i+j];

      // concat temp_char to the temp_word
      strcat(temp_word, &temp_char); // <= PROBLEM

      // add one to j
      j++;
    }

    // after the loop, concat the reversed version
    // of the word to the output
    strcat(output, reverseWord(temp_word));

    // if text[i+j] is space, concat space to the output
    if (text[i+j] == ' ')
      strcat(output, " ");

    // free the memory allocated for the temp_word
    free(temp_word);

    // add j to i, so u can skip 
    // the character that already read.
    i += j;
  }

  return output;
}

char *
reverseWord (char *word) {
  int i, j;
  size_t len = strlen(word);
  char *output;

  output = (char *) malloc (len + 1);

  j = 0;
  for(i = (len - 1); i >= 0; i--) {
    output[j++] = word[i];
  }

  return output;
}

问题是我用<= PROBLEM标记的那行，在这种情况下是“你好”的第一个词，它做的一切都很好。

在本例中是“世界”的第二个单词上，它在temp_word 中添加了垃圾字符， 我检查了gdb，temp_char 不包含垃圾，但是当strcat 运行时，附加到temp_word 的最新字符将类似于W\006，

它将\006附加到第二个单词中的所有字符，

我在终端上看到的输出很好，但是打印出strcmp 并将result 与expected_result 相比较返回-94。

• 可能是什么问题？
• \006 字符是什么？
• 为什么strcat加了？
• 如何防止这种行为？

Answer 1

strcat() 需要“C”字符串的第一个字符的地址，实际上是char-数组，其中至少有一个元素等于'\0'。

内存temp_word指向和内存&temp_char都不满足这样的要求。

因此，臭名昭著的未定义行为被调用，从那时起任何事情都可能发生。

一个可能的解决办法是改变

      temp_word = (char *) malloc (text_size + 1);

成为

      temp_word = malloc (text_size + 1); /* Not the issue but the cast is 
                                             just useless in C. */
      temp_word[0] = '\0';

还有这个

        strcat(temp_word, &temp_char);

成为

        strcat(temp_word, (char[2]){temp_char});

---

其余代码可能存在其他问题。

Answer 2

函数 strcat 处理字符串。

在这段代码中sn-p

  // assign and cast test[i+j] to temp_char as a character,
  // (it reads it as string by default)
  temp_char = (char) text[i+j];

  // concat temp_char to the temp_word
  strcat(temp_word, &temp_char); // <= PROBLEM

指针temp_word 和指针&temp_char 都不指向字符串。

此外，数组output 不附加终止零字符，例如当源字符串由空格组成时。

在任何情况下，您的方法都过于复杂，并且有许多冗余代码，例如 for 循环中的条件和 if 语句中的条件相互重复。

  for(i = 0; i < len; i++) {

    //…

    // if the text[i] is NULL, just get out of the loop
    if (text[i] == '\0') {
      break;
    }

函数可以写得更简单，如下面的演示程序所示。

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

char * reverse_words( const char *s )
{
    char *result = malloc( strlen( s ) + 1 );

    if ( result != NULL )
    {
        char *p = result;

        while ( *s != '\0' )
        {
            while ( isblank( ( unsigned char )*s ) )
            {
                *p++ = *s++;
            }


            const char *q = s;

            while ( !isblank( ( unsigned char )*q ) && *q != '\0' ) ++q;

            for ( const char *tmp = q; tmp != s; )
            {
                *p++ = *--tmp;
            }

            s = q;
        }

        *p = '\0';
    }

    return result;
}

int main(void) 
{
    const char *s = "Hello World";

    char *result = reverse_words( s );

    puts( s );
    puts( result );

    free( result );

    return 0;
}

程序输出是

Hello World
olleH dlroW

Answer 3

垃圾字符的根本原因是您对 strcat 函数的第二个参数使用了错误的输入。请参阅下面的说明：

在函数的开头声明：

  int i, j;
  size_t len = strlen(text);
  size_t text_size = len * sizeof(char);
  // output containst the output or the result
  char *output;

  // temp_word is a temporary variable,
  // it contains each word and it will be
  // empty after each space.
  char *temp_word;

  // temp_char is a temporary variable,
  // it contains the current character
  // within the for loop below.
  char temp_char;

您可以在堆栈中打印变量的地址，它们将是这样的：

printf("&temp_char=%p,&temp_word=%p,&output=%p,&text_size=%p\n", &temp_char, &temp_word,&output,&text_size);
result:    
&temp_char=0x7ffeea172a9f,&temp_word=0x7ffeea172aa0,&output=0x7ffeea172aa8,&text_size=0x7ffeea172ab0

如你所见，&temp_char(0x7ffeea172a9f)在栈底，接下来的1个字节是&temp_word(0x7ffeea172aa0)，接下来的8个字节是&output(0x7ffeea172aa8)，以此类推（我用的是64位操作系统，所以需要8 个字节为一个指针）

 // concat temp_char to the temp_word
  strcat(temp_word, &temp_char); // <= PROBLEM

请参阅此处的 strcat 描述：http://www.cplusplus.com/reference/cstring/strcat/

strcat 第二个参数 = &temp_char = 0x7ffeea172a9f。 strcat 认为 &temp_char(0x7ffeea172a9f) 是源字符串的起点，而不是像你期望的那样只添加一个字符，它将把所有从 &temp_char(0x7ffeea172a9f) 开始的字符追加到 temp_word ，直到它遇到终止空字符强>