C Неожиданные входы с символьными массивами

Question

Я работал с группой по проблеме практики Google Jam Jam (вы можете прочитать ее here). Наш код выглядит следующим образом:

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

main(){ 
    int c; 
    int n = 0; 
    int l = 0; 
    int d = 0; 
    int caseCount = 0; 
    int i = 0; 
    int j = 0; 
    //A boolean value used in determining parenthesees. 
    bool letBool = false; 
    //A boolean value used in determining something; 
    bool wordBool = false; 
    //Temporary space for test characters 
    char test[1000]; 
    //Gets word length 
    while((c=getchar())!=' ' && c!= '\n'){ 
    l = (l * 10) + c - '0'; 
    //printf("%d\n", l); 
    } 
    //Gets number of valid words. 
    while((c=getchar())!=' ' && c!= '\n'){ 
    d = (d * 10) + c - '0'; 
    //printf("%d\n", d); 
    } 
    //Gets number of test cases. 
    while((c=getchar())!= '\n'){ 
    n = (n * 10) + c - '0'; 
    //printf("%d\n", n); 
    } 
    //Array of all valid words. 
    char dict[d][l]; 
    c=getchar(); 
    //While we still have words to read in. 
    while(i < d){ 
    //If not new line 
    if(c!='\n'){ 
     //Then read character 
     dict[i][j] = c; 
    } 
    else{ 
     i++; 
     j=0; 
    } 
    c=getchar(); 
    j++; 
    } 
    i = 0; 
    j = 0; 
    while(i < n){ 
    j = 0; 
    while((c=getchar())!='\n' && c!=EOF){ 
     putchar(c); 
     test[j] = c; 
     j++; 
    } 
    putchar('\n'); 
    test[j+1] = '\0'; 
    printf("%s\n", test); 
    int word = 0; 
    //Going through valid words 
    while(word < d){ 
     wordBool=true; 
     j = 0; 
     int letter = 0; 
     //Going through valid letters 
     while(letter < l){ 
     letBool=false; 
     if(test[j] == '('){ 
      while(test[j++]!=')'){ 
      if(dict[word][letter]==test[j]){ 
       letBool=true; 
       //printf("%s%d%s%d\n" "letBool is true at word: ", word, "letter: ", letter); 
      } 
      } 
     } 
     else{ 
      if(test[j]==dict[word][letter]){ 
      letBool=true; 
      //printf("%s%d%s%d\n" "letBool is true at word: ", word, "letter: ", letter); 
      } 
     } 
     j++; 
     letter++; 
     if(!letBool){ 
      wordBool=false; 
      //printf("%s%d%s%d\n" "wordBool is false at word: ", word, "letter: ", letter); 
     } 
     } 
     if(wordBool){ 
     caseCount++; 
     } 
     word++; 
    } 
    printf("%s%d%s%d\n", "Case #", i+1, ": ", caseCount); 
    i++; 
    j=0; 
    caseCount=0; 
    } 
} 

Проблема заключается выход, кажется, правильно читать вход для «получил чуждо код» части с вне putchar, но когда он вводится в опытную случае повреждается. Вот часть я говорю:

while((c=getchar())!='\n' && c!=EOF){ 
     putchar(c); 
     test[j] = c; 
     j++; 
    } 
    putchar('\n'); 
    test[j+1] = '\0'; 
    printf("%s\n", test); 

Когда мы даем ему этот вход:

3 5 4 
abc 
bca 
dac 
dbc 
cba 
(ab)(bc)(ca) 
abc 
(abc)(abc)(abc) 
(zyx)bc 

мы получаем

ab)(bc)(ca) 
ab)(bc)(ca) 
7 
Case #1: 0 
abc 
abc 
b 
Case #2: 1 
(abc)(abc)(abc) 
(abc)(abc)(abc) 
Case #3: 0 
(zyx)bc 
(zyx)bcb 
Case #4: 0 

(
Case #5: 0 

Таким образом, мы не можем понять, почему случайны символы, такие как 7 и b, распечатываются.

Answer 1

Изменить это:

test[j+1] = '\0'; 

к этому:

test[j] = '\0'; 

Причина заключается в том, что вы уже увеличивается значение j «s, в конце цикла в то время, до того, как условие терминатор был встречен :

j = 0; 
while((c=getchar())!='\n' && c!=EOF){ 
    putchar(c); 
    test[j] = c; 
    j++; <------ 
} 
putchar('\n'); 
test[j] = '\0'; 

Так, с test[j + 1], вы на самом деле S скопировал ячейку. Это означает, что вы испытываете Неопределенное поведение, так как эта пропущенная ячейка содержит мусор, поскольку test не был инициализирован ни к чему. В результате мы не знаем, что содержит эта ячейка, она содержит мусор.

Выход с исправленным кодом:

gsamaras@gsamaras:~$ gcc -Wall px.c 
gsamaras@gsamaras:~$ ./a.out 
3 5 4 
abc 
bca 
dac 
dbc 
cba 
(ab)(bc)(ca) 
abc 
(abc)(abc)(abc) 
(zyx)bcab)(bc)(ca) 
ab)(bc)(ca) 
Case #1: 0 
abc 
abc 
Case #2: 1 
(abc)(abc)(abc) 
(abc)(abc)(abc) 
Case #3: 0 

(zyx)bc 
(zyx)bc 
Case #4: 0 

---

Кроме того, использование:

int main(void) { 
    ... 
    return 0; 
} 

Более подробную информацию, прочитать: What should main() return in C and C++?