在C中将字符附加到空字符串：

huangapple
go评论89阅读模式
英文:

Appending Characters to an Empty String in C

问题

我对C语言相对较新，所以任何帮助理解正在发生的事情都将非常棒！

我有一个名为Token的结构体，定义如下：

  1. //Token结构体
  2. struct Token {
  3.     char type[16];
  4.     char value[1024];
  5. };

我试图从文件中读取字符，并将从文件中读取的字符附加到Token.value中，如下所示：

  1.     struct Token newToken;
  2.     char ch;
  3.     ch = fgetc(file);
  4.     strncat(newToken.value, &ch, 1);

这是有效的！

我的问题是，Token.value以我不理解的几个值开头，然后是我附加的字符。当我将newToken.value的结果打印到控制台时，我得到@�����TheCharactersIWantedToAppend。如果可能的话，我可以想办法事后删除或绕过这些字符，但如果不必要，我宁愿不这样做。

在分析�字符时，我发现它们依次为索引1到5的字符：\330, \377, \377, \377, \177。我了解\377在C中是EOF的特殊字符，但在十进制中也是255。这些值是否构成内存地址？通过在strncat中使用&ch将地址添加到newToken.value中吗？如果是这样，如何防止它们进入newToken.value？

注意： 如果我使用strncat(newToken.value, ch, 1)而不是strncat(newToken.value, &ch, 1)（ch与&ch），我会得到分段错误。

英文:

I'm relatively new to C, so any help understanding what's going on would be awesome!!!

I have a struct called Token that is as follows:

  1. //Token struct
  2. struct Token {
  3.     char type[16];
  4.     char value[1024];
  5. };

I am trying to read from a file and append characters read from the file into Token.value like so:

  1.     struct Token newToken;
  2.     char ch;
  3.     ch = fgetc(file);
  4.     strncat(newToken.value, &ch, 1);

THIS WORKS!

My problem is that Token.value begins with several values I don't understand, preceding the characters that I appended. When I print the result of newToken.value to the console, I get @�����TheCharactersIWantedToAppend. I could probably figure out a band-aid solution to retroactively remove or work around these characters, but I'd rather not if I don't have to.

In analyzing the � characters, I see them as (in order from index 1-5): \330, \377, \377, \377, \177. I read that \377 is a special character for EOF in C, but also 255 in decimal? Do these values make up a memory address? Am I adding the address to newToken.value by using &ch in strncat? If so, how can I keep them from getting into newToken.value?

Note: I get a segmentation fault if I use strncat(newToken.value, ch, 1) instead of strncat(newToken.value, &ch, 1) (ch vs. &ch).

答案1

得分: 2

以下是您要翻译的部分：

  1. I'll try to consolidate the answers already given in the comments.
  3. This version of the code uses `strncat()`, as yours, but solving the problems noted by Nick (we must initialize the target) and Dúthomhas (the second parameter to `strncat()` must be a string, and not a pointer to a single char) (Yes, a "string" is actually a `char[]` and the value passed to the function is a `char*`; but it must point to an array *of at least two chars*, the last one containing a `'
    I'll try to consolidate the answers already given in the comments.
  4. This version of the code uses `strncat()`, as yours, but solving the problems noted by Nick (we must initialize the target) and Dúthomhas (the second parameter to `strncat()` must be a string, and not a pointer to a single char) (Yes, a "string" is actually a `char[]` and the value passed to the function is a `char*`; but it must point to an array *of at least two chars*, the last one containing a `'\0'`.)
  5. Please be aware that `strncat()`, `strncpy()` and all related functions are tricky. They don't write more than N chars. But `strncpy()` only adds the final `'\0'` to the target string when the source has ***less*** than N chars; and `strncat()` ***always*** adds it, even if it the source has exactly N chars or more (edited; thanks, @Clifford).
  6. '`.)
  8. Please be aware that `strncat()`, `strncpy()` and all related functions are tricky. They don't write more than N chars. But `strncpy()` only adds the final `'
    I'll try to consolidate the answers already given in the comments.
  9. This version of the code uses `strncat()`, as yours, but solving the problems noted by Nick (we must initialize the target) and Dúthomhas (the second parameter to `strncat()` must be a string, and not a pointer to a single char) (Yes, a "string" is actually a `char[]` and the value passed to the function is a `char*`; but it must point to an array *of at least two chars*, the last one containing a `'\0'`.)
  10. Please be aware that `strncat()`, `strncpy()` and all related functions are tricky. They don't write more than N chars. But `strncpy()` only adds the final `'\0'` to the target string when the source has ***less*** than N chars; and `strncat()` ***always*** adds it, even if it the source has exactly N chars or more (edited; thanks, @Clifford).
  11. '` to the target string when the source has ***less*** than N chars; and `strncat()` ***always*** adds it, even if it the source has exactly N chars or more (edited; thanks, @Clifford).
  1. #include <stdio.h>
  2. #include <string.h>
  4. int main() {
  5.     FILE* file = stdin; // fopen("test.txt", "r");
  6.     if (file) {
  7.         struct Token {
  8.             char type[16];
  9.             char value[1024];
  10.         };
  12.         struct Token newToken;
  13.         newToken.value[0] = '\0';                       // A '
    #include <stdio.h>
  14. #include <string.h>
  16. int main() {
  17.     FILE* file = stdin; // fopen("test.txt", "r");
  18.     if (file) {
  19.         struct Token {
  20.             char type[16];
  21.             char value[1024];
  22.         };
  24.         struct Token newToken;
  25.         newToken.value[0] = '\0';                       // A '\0' at the first position means "empty"
  27.         int aux;
  28.         char source[2] = "";                            // A literal "" has a single char with value '\0', but this syntax fills the entire array with '\0's
  29.         while ((aux = fgetc(file)) != EOF) {
  30.             source[0] = (char)aux;
  31.             strncat(newToken.value, source, 1);         // This appends AT MOST 1 CHAR (and always adds a final '\0')
  32.         }
  34.         strncat(newToken.value, "", 1);                 // As the source string is empty, it just adds a final '\0' (superfluous in this case)
  35.         printf(newToken.value);
  36.     }
  37.     return 0;
  38. }
  39. ' at the first position means "empty"
  41.         int aux;
  42.         char source[2] = "";                            // A literal "" has a single char with value '
    #include <stdio.h>
  43. #include <string.h>
  45. int main() {
  46.     FILE* file = stdin; // fopen("test.txt", "r");
  47.     if (file) {
  48.         struct Token {
  49.             char type[16];
  50.             char value[1024];
  51.         };
  53.         struct Token newToken;
  54.         newToken.value[0] = '\0';                       // A '\0' at the first position means "empty"
  56.         int aux;
  57.         char source[2] = "";                            // A literal "" has a single char with value '\0', but this syntax fills the entire array with '\0's
  58.         while ((aux = fgetc(file)) != EOF) {
  59.             source[0] = (char)aux;
  60.             strncat(newToken.value, source, 1);         // This appends AT MOST 1 CHAR (and always adds a final '\0')
  61.         }
  63.         strncat(newToken.value, "", 1);                 // As the source string is empty, it just adds a final '\0' (superfluous in this case)
  64.         printf(newToken.value);
  65.     }
  66.     return 0;
  67. }
  68. ', but this syntax fills the entire array with '
    #include <stdio.h>
  69. #include <string.h>
  71. int main() {
  72.     FILE* file = stdin; // fopen("test.txt", "r");
  73.     if (file) {
  74.         struct Token {
  75.             char type[16];
  76.             char value[1024];
  77.         };
  79.         struct Token newToken;
  80.         newToken.value[0] = '\0';                       // A '\0' at the first position means "empty"
  82.         int aux;
  83.         char source[2] = "";                            // A literal "" has a single char with value '\0', but this syntax fills the entire array with '\0's
  84.         while ((aux = fgetc(file)) != EOF) {
  85.             source[0] = (char)aux;
  86.             strncat(newToken.value, source, 1);         // This appends AT MOST 1 CHAR (and always adds a final '\0')
  87.         }
  89.         strncat(newToken.value, "", 1);                 // As the source string is empty, it just adds a final '\0' (superfluous in this case)
  90.         printf(newToken.value);
  91.     }
  92.     return 0;
  93. }
  94. 's
  95.         while ((aux = fgetc(file)) != EOF) {
  96.             source[0] = (char)aux;
  97.             strncat(newToken.value, source, 1);         // This appends AT MOST 1 CHAR (and always adds a final '
    #include <stdio.h>
  98. #include <string.h>
  100. int main() {
  101.     FILE* file = stdin; // fopen("test.txt", "r");
  102.     if (file) {
  103.         struct Token {
  104.             char type[16];
  105.             char value[1024];
  106.         };
  108.         struct Token newToken;
  109.         newToken.value[0] = '\0';                       // A '\0' at the first position means "empty"
  111.         int aux;
  112.         char source[2] = "";                            // A literal "" has a single char with value '\0', but this syntax fills the entire array with '\0's
  113.         while ((aux = fgetc(file)) != EOF) {
  114.             source[0] = (char)aux;
  115.             strncat(newToken.value, source, 1);         // This appends AT MOST 1 CHAR (and always adds a final '\0')
  116.         }
  118.         strncat(newToken.value, "", 1);                 // As the source string is empty, it just adds a final '\0' (superfluous in this case)
  119.         printf(newToken.value);
  120.     }
  121.     return 0;
  122. }
  123. ')
  124.         }
  126.         strncat(newToken.value, "", 1);                 // As the source string is empty, it just adds a final '
    #include <stdio.h>
  127. #include <string.h>
  129. int main() {
  130.     FILE* file = stdin; // fopen("test.txt", "r");
  131.     if (file) {
  132.         struct Token {
  133.             char type[16];
  134.             char value[1024];
  135.         };
  137.         struct Token newToken;
  138.         newToken.value[0] = '\0';                       // A '\0' at the first position means "empty"
  140.         int aux;
  141.         char source[2] = "";                            // A literal "" has a single char with value '\0', but this syntax fills the entire array with '\0's
  142.         while ((aux = fgetc(file)) != EOF) {
  143.             source[0] = (char)aux;
  144.             strncat(newToken.value, source, 1);         // This appends AT MOST 1 CHAR (and always adds a final '\0')
  145.         }
  147.         strncat(newToken.value, "", 1);                 // As the source string is empty, it just adds a final '\0' (superfluous in this case)
  148.         printf(newToken.value);
  149.     }
  150.     return 0;
  151. }
  152. ' (superfluous in this case)
  153.         printf(newToken.value);
  154.     }
  155.     return 0;
  156. }
  1. This other version uses an `index` variable and writes each singe char directly into the "current" position of the target string, without using `strncat()`. I think is simpler and more secure, because it doesn't mix the confusing semantics of single chars and strings.
  1. #include <stdio.h>
  2. #include <string.h>
  4. int main() {
  5.     FILE* file = stdin; // fopen("test.txt", "r");
  6.     if (file) {
  7.         struct Token {
  8.             int index = 0;
  9.             char type[16];
  10.             char value[1024];        // Max size is 1023 chars + '
    #include <stdio.h>
  11. #include <string.h>
  13. int main() {
  14.     FILE* file = stdin; // fopen("test.txt", "r");
  15.     if (file) {
  16.         struct Token {
  17.             int index = 0;
  18.             char type[16];
  19.             char value[1024];        // Max size is 1023 chars + '\0'
  20.         };
  22.         struct Token newToken;
  23.         newToken.value[0] = '\0';    // A '\0' at the first position means "empty". This is not really necessary anymore
  25.         int aux;
  26.         while ((aux = fgetc(file)) != EOF)
  27.             // Index will stop BEFORE 1024-1 (value[1022] will be the last "real" char, leaving space for a final '\0')
  28.             if (newToken.index < sizeof newToken.value -1)
  29.                 newToken.value[newToken.index++] = (char)aux;
  31.         newToken.value[newToken.index++] = '\0';
  32.         printf(newToken.value);
  33.     }
  34.     return 0;
  35. }
  36. '
  37.         };
  39.         struct Token newToken;
  40.         newToken.value[0] = '\0';    // A '
    #include <stdio.h>
  41. #include <string.h>
  43. int main() {
  44.     FILE* file = stdin; // fopen("test.txt", "r");
  45.     if (file) {
  46.         struct Token {
  47.             int index = 0;
  48.             char type[16];
  49.             char value[1024];        // Max size is 1023 chars + '\0'
  50.         };
  52.         struct Token newToken;
  53.         newToken.value[0] = '\0';    // A '\0' at the first position means "empty". This is not really necessary anymore
  55.         int aux;
  56.         while ((aux = fgetc(file)) != EOF)
  57.             // Index will stop BEFORE 1024-1 (value[1022] will be the last "real" char, leaving space for a final '\0')
  58.             if (newToken.index < sizeof newToken.value -1)
  59.                 newToken.value[newToken.index++] = (char)aux;
  61.         newToken.value[newToken.index++] = '\0';
  62.         printf(newToken.value);
  63.     }
  64.     return 0;
  65. }
  66. ' at the first position means "empty". This is not really necessary anymore
  68.         int aux;
  69.         while ((aux = fgetc(file)) != EOF)
  70.             // Index will stop BEFORE 1024-1 (value[1022] will be the last "real" char, leaving space for a final '
    #include <stdio.h>
  71. #include <string.h>
  73. int main() {
  74.     FILE* file = stdin; // fopen("test.txt", "r");
  75.     if (file) {
  76.         struct Token {
  77.             int index = 0;
  78.             char type[16];
  79.             char value[1024];        // Max size is 1023 chars + '\0'
  80.         };
  82.         struct Token newToken;
  83.         newToken.value[0] = '\0';    // A '\0' at the first position means "empty". This is not really necessary anymore
  85.         int aux;
  86.         while ((aux = fgetc(file)) != EOF)
  87.             // Index will stop BEFORE 1024-1 (value[1022] will be the last "real" char, leaving space for a final '\0')
  88.             if (newToken.index < sizeof newToken.value -1)
  89.                 newToken.value[newToken.index++] = (char)aux;
  91.         newToken.value[newToken.index++] = '\0';
  92.         printf(newToken.value);
  93.     }
  94.     return 0;
  95. }
  96. ')
  97.             if (newToken.index < sizeof newToken.value -1)
  98.                 newToken.value[newToken.index++] = (char)aux;
  100.         newToken.value[newToken.index++] = '\0';
  101.         printf(newToken.value);
  102.     }
  103.     return 0;
  104. }

Edited: fgetc() returns an int and we should check for EOF before casting it to a char (thanks, @chqrlie).

  2. <details>
  3. <summary>英文:</summary>
  5. I&#39;ll try to consolidate the answers already given in the comments.
  7. This version of the code uses `strncat()`, as yours, but solving the problems noted by Nick (we must initialize the target) and D&#250;thomhas (the second parameter to `strncat()` must be a string, and not a pointer to a single char) (Yes, a &quot;string&quot; is actually a `char[]` and the value passed to the function is a `char*`; but it must point to an array *of at least two chars*, the last one containing a `&#39;
  8. <details>
  9. <summary>英文:</summary>
  10. I&#39;ll try to consolidate the answers already given in the comments.
  11. This version of the code uses `strncat()`, as yours, but solving the problems noted by Nick (we must initialize the target) and D&#250;thomhas (the second parameter to `strncat()` must be a string, and not a pointer to a single char) (Yes, a &quot;string&quot; is actually a `char[]` and the value passed to the function is a `char*`; but it must point to an array *of at least two chars*, the last one containing a `&#39;\0&#39;`.)
  12. Please be aware that `strncat()`, `strncpy()` and all related functions are tricky. They don&#39;t write more than N chars. But `strncpy()` only adds the final `&#39;\0&#39;` to the target string when the source has ***less*** than N chars; and `strncat()` ***always*** adds it, even if it the source has exactly N chars or more (edited; thanks, @Clifford).
  13. &#39;`.)
  15. Please be aware that `strncat()`, `strncpy()` and all related functions are tricky. They don&#39;t write more than N chars. But `strncpy()` only adds the final `&#39;
  16. <details>
  17. <summary>英文:</summary>
  18. I&#39;ll try to consolidate the answers already given in the comments.
  19. This version of the code uses `strncat()`, as yours, but solving the problems noted by Nick (we must initialize the target) and D&#250;thomhas (the second parameter to `strncat()` must be a string, and not a pointer to a single char) (Yes, a &quot;string&quot; is actually a `char[]` and the value passed to the function is a `char*`; but it must point to an array *of at least two chars*, the last one containing a `&#39;\0&#39;`.)
  20. Please be aware that `strncat()`, `strncpy()` and all related functions are tricky. They don&#39;t write more than N chars. But `strncpy()` only adds the final `&#39;\0&#39;` to the target string when the source has ***less*** than N chars; and `strncat()` ***always*** adds it, even if it the source has exactly N chars or more (edited; thanks, @Clifford).
  21. &#39;` to the target string when the source has ***less*** than N chars; and `strncat()` ***always*** adds it, even if it the source has exactly N chars or more (edited; thanks, @Clifford).

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

int main() {
FILE* file = stdin; // fopen("test.txt", "r");
if (file) {
struct Token {
char type[16];
char value[1024];
};

  1.     struct Token newToken;
  2.     newToken.value[0] = &#39;
        struct Token newToken;
  3. newToken.value[0] = &#39;\0&#39;;                       // A &#39;\0&#39; at the first position means &quot;empty&quot;
  4. int aux;
  5. char source[2] = &quot;&quot;;                            // A literal &quot;&quot; has a single char with value &#39;\0&#39;, but this syntax fills the entire array with &#39;\0&#39;s
  6. while ((aux = fgetc(file)) != EOF) {
  7. source[0] = (char)aux;
  8. strncat(newToken.value, source, 1);         // This appends AT MOST 1 CHAR (and always adds a final &#39;\0&#39;)
  9. }
  10. strncat(newToken.value, &quot;&quot;, 1);                 // As the source string is empty, it just adds a final &#39;\0&#39; (superfluous in this case)
  11. printf(newToken.value);
  12. }
  13. return 0;
  14. &#39;;                       // A &#39;
        struct Token newToken;
  15. newToken.value[0] = &#39;\0&#39;;                       // A &#39;\0&#39; at the first position means &quot;empty&quot;
  16. int aux;
  17. char source[2] = &quot;&quot;;                            // A literal &quot;&quot; has a single char with value &#39;\0&#39;, but this syntax fills the entire array with &#39;\0&#39;s
  18. while ((aux = fgetc(file)) != EOF) {
  19. source[0] = (char)aux;
  20. strncat(newToken.value, source, 1);         // This appends AT MOST 1 CHAR (and always adds a final &#39;\0&#39;)
  21. }
  22. strncat(newToken.value, &quot;&quot;, 1);                 // As the source string is empty, it just adds a final &#39;\0&#39; (superfluous in this case)
  23. printf(newToken.value);
  24. }
  25. return 0;
  26. &#39; at the first position means &quot;empty&quot;
  28.     int aux;
  29.     char source[2] = &quot;&quot;;                            // A literal &quot;&quot; has a single char with value &#39;
        struct Token newToken;
  30. newToken.value[0] = &#39;\0&#39;;                       // A &#39;\0&#39; at the first position means &quot;empty&quot;
  31. int aux;
  32. char source[2] = &quot;&quot;;                            // A literal &quot;&quot; has a single char with value &#39;\0&#39;, but this syntax fills the entire array with &#39;\0&#39;s
  33. while ((aux = fgetc(file)) != EOF) {
  34. source[0] = (char)aux;
  35. strncat(newToken.value, source, 1);         // This appends AT MOST 1 CHAR (and always adds a final &#39;\0&#39;)
  36. }
  37. strncat(newToken.value, &quot;&quot;, 1);                 // As the source string is empty, it just adds a final &#39;\0&#39; (superfluous in this case)
  38. printf(newToken.value);
  39. }
  40. return 0;
  41. &#39;, but this syntax fills the entire array with &#39;
        struct Token newToken;
  42. newToken.value[0] = &#39;\0&#39;;                       // A &#39;\0&#39; at the first position means &quot;empty&quot;
  43. int aux;
  44. char source[2] = &quot;&quot;;                            // A literal &quot;&quot; has a single char with value &#39;\0&#39;, but this syntax fills the entire array with &#39;\0&#39;s
  45. while ((aux = fgetc(file)) != EOF) {
  46. source[0] = (char)aux;
  47. strncat(newToken.value, source, 1);         // This appends AT MOST 1 CHAR (and always adds a final &#39;\0&#39;)
  48. }
  49. strncat(newToken.value, &quot;&quot;, 1);                 // As the source string is empty, it just adds a final &#39;\0&#39; (superfluous in this case)
  50. printf(newToken.value);
  51. }
  52. return 0;
  53. &#39;s
  54.     while ((aux = fgetc(file)) != EOF) {
  55.         source[0] = (char)aux;
  56.         strncat(newToken.value, source, 1);         // This appends AT MOST 1 CHAR (and always adds a final &#39;
        struct Token newToken;
  57. newToken.value[0] = &#39;\0&#39;;                       // A &#39;\0&#39; at the first position means &quot;empty&quot;
  58. int aux;
  59. char source[2] = &quot;&quot;;                            // A literal &quot;&quot; has a single char with value &#39;\0&#39;, but this syntax fills the entire array with &#39;\0&#39;s
  60. while ((aux = fgetc(file)) != EOF) {
  61. source[0] = (char)aux;
  62. strncat(newToken.value, source, 1);         // This appends AT MOST 1 CHAR (and always adds a final &#39;\0&#39;)
  63. }
  64. strncat(newToken.value, &quot;&quot;, 1);                 // As the source string is empty, it just adds a final &#39;\0&#39; (superfluous in this case)
  65. printf(newToken.value);
  66. }
  67. return 0;
  68. &#39;)
  69.     }
  71.     strncat(newToken.value, &quot;&quot;, 1);                 // As the source string is empty, it just adds a final &#39;
        struct Token newToken;
  72. newToken.value[0] = &#39;\0&#39;;                       // A &#39;\0&#39; at the first position means &quot;empty&quot;
  73. int aux;
  74. char source[2] = &quot;&quot;;                            // A literal &quot;&quot; has a single char with value &#39;\0&#39;, but this syntax fills the entire array with &#39;\0&#39;s
  75. while ((aux = fgetc(file)) != EOF) {
  76. source[0] = (char)aux;
  77. strncat(newToken.value, source, 1);         // This appends AT MOST 1 CHAR (and always adds a final &#39;\0&#39;)
  78. }
  79. strncat(newToken.value, &quot;&quot;, 1);                 // As the source string is empty, it just adds a final &#39;\0&#39; (superfluous in this case)
  80. printf(newToken.value);
  81. }
  82. return 0;
  83. &#39; (superfluous in this case)
  84.     printf(newToken.value);
  85. }
  86. return 0;

}

  1. This other version uses an `index` variable and writes each singe char directly into the &quot;current&quot; position of the target string, without using `strncat()`. I think is simpler and more secure, because it doesn&#39;t mix the confusing semantics of single chars and strings.

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

int main() {
FILE* file = stdin; // fopen("test.txt", "r");
if (file) {
struct Token {
int index = 0;
char type[16];
char value[1024]; // Max size is 1023 chars + '\0'
};

  1.     struct Token newToken;
  2.     newToken.value[0] = &#39;
        struct Token newToken;
  3. newToken.value[0] = &#39;\0&#39;;    // A &#39;\0&#39; at the first position means &quot;empty&quot;. This is not really necessary anymore
  4. int aux;
  5. while ((aux = fgetc(file)) != EOF)
  6. // Index will stop BEFORE 1024-1 (value[1022] will be the last &quot;real&quot; char, leaving space for a final &#39;\0&#39;)
  7. if (newToken.index &lt; sizeof newToken.value -1)
  8. newToken.value[newToken.index++] = (char)aux;
  9. newToken.value[newToken.index++] = &#39;\0&#39;;
  10. printf(newToken.value);
  11. }
  12. return 0;
  13. &#39;;    // A &#39;
        struct Token newToken;
  14. newToken.value[0] = &#39;\0&#39;;    // A &#39;\0&#39; at the first position means &quot;empty&quot;. This is not really necessary anymore
  15. int aux;
  16. while ((aux = fgetc(file)) != EOF)
  17. // Index will stop BEFORE 1024-1 (value[1022] will be the last &quot;real&quot; char, leaving space for a final &#39;\0&#39;)
  18. if (newToken.index &lt; sizeof newToken.value -1)
  19. newToken.value[newToken.index++] = (char)aux;
  20. newToken.value[newToken.index++] = &#39;\0&#39;;
  21. printf(newToken.value);
  22. }
  23. return 0;
  24. &#39; at the first position means &quot;empty&quot;. This is not really necessary anymore
  26.     int aux;
  27.     while ((aux = fgetc(file)) != EOF)
  28.         // Index will stop BEFORE 1024-1 (value[1022] will be the last &quot;real&quot; char, leaving space for a final &#39;
        struct Token newToken;
  29. newToken.value[0] = &#39;\0&#39;;    // A &#39;\0&#39; at the first position means &quot;empty&quot;. This is not really necessary anymore
  30. int aux;
  31. while ((aux = fgetc(file)) != EOF)
  32. // Index will stop BEFORE 1024-1 (value[1022] will be the last &quot;real&quot; char, leaving space for a final &#39;\0&#39;)
  33. if (newToken.index &lt; sizeof newToken.value -1)
  34. newToken.value[newToken.index++] = (char)aux;
  35. newToken.value[newToken.index++] = &#39;\0&#39;;
  36. printf(newToken.value);
  37. }
  38. return 0;
  39. &#39;)
  40.         if (newToken.index &lt; sizeof newToken.value -1)
  41.             newToken.value[newToken.index++] = (char)aux;
  43.     newToken.value[newToken.index++] = &#39;
        struct Token newToken;
  44. newToken.value[0] = &#39;\0&#39;;    // A &#39;\0&#39; at the first position means &quot;empty&quot;. This is not really necessary anymore
  45. int aux;
  46. while ((aux = fgetc(file)) != EOF)
  47. // Index will stop BEFORE 1024-1 (value[1022] will be the last &quot;real&quot; char, leaving space for a final &#39;\0&#39;)
  48. if (newToken.index &lt; sizeof newToken.value -1)
  49. newToken.value[newToken.index++] = (char)aux;
  50. newToken.value[newToken.index++] = &#39;\0&#39;;
  51. printf(newToken.value);
  52. }
  53. return 0;
  54. &#39;;
  55.     printf(newToken.value);
  56. }
  57. return 0;

}

  1. **Edited**: `fgetc()` returns an `int` and we should check for EOF *before* casting it to a `char` (thanks, @chqrlie).
  3. </details>
  7. # 答案2
  8. **得分**: 1
  10. 以下是翻译的内容：
  12. 你正在附加未初始化的字符串，因此可能包含_任何内容_。字符串的结束由NUL(0)字符表示，在你的示例中，在6个字节后恰好有一个，但`value`数组中可能没有任何字符，因此代码存在严重缺陷，会导致不确定的行为。
  14. 你需要将`newToken`实例初始化为空字符串。例如：
  16. ```C
  17. struct Token newToken = { "", "" };

或者初始化整个结构为零：

  1. struct Token newToken = { 0 };

关键是，C语言不会初始化非静态对象，除非有明确的初始值。

此外，使用strncat()非常低效，具有取决于目标字符串长度的不确定执行时间（请参考https://www.joelonsoftware.com/2001/12/11/back-to-basics/）。

在这种情况下，你最好维护已添加的字符数，并直接将字符和终止符写入数组。例如：

  1. size_t index;
  2. int ch = 0;
  4. do
  5. {
  6.     ch = fgetc(file);
  7.     if (ch != EOF)
  8.     {
  9.         newToken.value[index] = (char)ch;
  10.         index++;
  11.         newToken.value[index] = '
    size_t index;
  12. int ch = 0;
  14. do
  15. {
  16.     ch = fgetc(file);
  17.     if (ch != EOF)
  18.     {
  19.         newToken.value[index] = (char)ch;
  20.         index++;
  21.         newToken.value[index] = '\0';
  22.     }
  23. } while (ch != EOF &&
  24.          index < sizeof(newToken.value) - 1);
  25. ';
  26.     }
  27. } while (ch != EOF &&
  28.          index < sizeof(newToken.value) - 1);
英文:

You are appending string that is not initialised, so can contain anything. The end I'd a string is indicated by a NUL(0) character, and in your example there happened to be one after 6 bytes, but there need not be any within the value array, so the code is seriously flawed, and will result in non-deterministic behaviour.

You need to initialise the newToken instance to empty string. For example:

  1. struct Token newToken = { &quot;&quot;, &quot;&quot; } ;

or to zero initialise the whole structure:

  1. struct Token newToken = { 0 } ;

The point is that C does not initialise non-static objects without an explicit initialiser.

Furthermore using strncat() is very inefficient and has non-deterministic execution time that depends on the length of the destination string (see https://www.joelonsoftware.com/2001/12/11/back-to-basics/).

In this case you would do better to maintain a count of the number of characters added, and write the character and terminator directly to the array. For example:

  1. size_t index ;
  2. int ch = 0 ;
  4. do
  5. {
  6.     ch = fgetc(file);
  7.     if( ch != EOF ) 
  8.     {
  9.         newToken.value[index] = (char)ch ;
  10.         index++ ;
  11.         newToken.value[index] = &#39;\0&#39; ;
  12.     }
  13. } while( ch != EOF &amp;&amp; 
  14.          index &lt; size of(newToken.value) - 1 ) ;

huangapple
  • 本文由 发表于 2023年2月16日 10:52:43
  • 转载请务必保留本文链接：https://go.coder-hub.com/75467376.html
  • c
  • char
  • memory-address
  • string
  • string-concatenation
匿名

发表评论

匿名网友

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen:

确定