额外的错误？他们在哪里？他们是什么？ C编程

Question

我的代码已被反复校对，我仍然无法弄清楚为什么这些代码中的一部分会发出错误消息。只有一个'}'的行被调用为错误。这怎么可能？

#include <stdio.h> 
#include <getword.h> 
#define STORAGE 255 

int getword(char *w) { 

char *word = w; /*points to first char in array */ 
char iochar; /*holds current var being processed */ 
int counter = 0; /* counts number of characters in a word */ 
char *first = w; /* points to first character in array */ 
int bslashflag = 0; /* 0 if no backslash seen, 1 otherwise */ 
int negateornah = 0; /* if set to 1, return value is negated */ 

while((iochar = getchar()) != EOF) { /*runs until EOF is encountered */ 

if(iochar =='\\')  /* if a slash char is found in the word*/ 
{ bslashflag = 1;    /*acknowledge that*/ 
        /*backslash was seen*/ 
    iochar = getchar();  /* skip it & go to the next char*/ 
    if(iochar == '\'){  /*and if it ends up being another*/ 
       /*slash, slash designated to be added in */ 
     *word = iochar; /* so go ahead and add it in */ 
     *word++;   /* and go to the next empty slot */ 
     counter++; /*and increment your counter */ 
     iochar = getchar(); /* *ALERT << may or may not beneccessary */ 
    } else if(iochar == '<' || iochar == '>' || iochar == '|' || iochar == '$' || iochar == '&') 
      {  /* if a metacharacter is found after a bslash, */ 
         /*just treat it like any other character*/ 
     *word = iochar; 
     *word++; 
     counter+=1; 
      } 
}  
else if (iochar == ' ') 
{ 
    if(counter == 0) //*f the first char is a space */ 
    {  
    while((iochar = getchar()) == ' ') { } /*skips leading blanks*/ 

    } else if(bslashflag == 1) { /*if there was bslash before space*/ 
     *word++ = iochar;  /*add the space as part of string*/ 
    counter++; /*increments counter*/ 
    bslashflag--; /*resets backslash flag for next char check*/ 
    } 
    else 
    {   /* until alphanum char is found*/ 
      *word = '\0'; /*if not leading blank, its the end of word*/ 

     if(negateornah == 1) 
     { 
     negateornah= 0; /*reset flag for next run*/ 
     counter *= -1; /*negate the value in counter*/ 
     return counter; 
     } 

     return counter; /* return word size */ 
    } 
} 

else if(iochar == '\n' || iochar == '<' || iochar == '>' || iochar == '|' || iochar == '$' || iochar == '&') 
{  /*if a metacharacter is encountered*/ 

    if(iochar == '\n' && counter == 0) /* if the first char in the word is \n */ 
    { 
     *word = '\0'; /* and null terminate the array; TRY *first INCASE OF ERROR*/ 
     if(negateornah == 1) { 
      negateornah= 0; /*reset flag for next run*/ 
      counter *= -1; /*negate the value in counter*/ 
      return counter; 
     } 
     return counter; /* null terminate the array and return count so scan can continue*/ 
    } 
    else if(iochar == '\n' && counter != 0) 
    { 
     *word = '\0' ; 
     ungetc('\n',stdin); /* put it back where you got it*/ 
     if(negateornah == 1) { 
      negateornah= 0; /*reset flag for next run*/ 
      counter *= -1; /*negate the value in counter*/ 
      return counter; 
     } 
     return counter;  /*and return a number so the scan can continue*/ 
    } 

    else if(iochar == '$') 
    { 
     if(counter ==0) { 
      negateornah = 1; } /*means $ was first char in word, set negate count flag*/ 
     if(bslashflag == 1) /* if a backslash was seen before this character*/ 
     {   
      *word = iochar; /* just add it into the word*/ 

      *word++; /* as part of the string*/ 
      counter++; /* and count it as a letter*/ 
      bslashflag=0; /*reset flag for next check*/ 
     } 
     *word++ = iochar; /*add it into word*/ 

     counter++; /*and account for addition*/ 
     return counter; 

    } 

    else if(iochar == '|') { 
     if(counter==0){ 
      *word = iochar; 
      *word++; 
      counter++ 
      return counter; 
     } 
     if(bslashflag == 1) { 
      *word = iochar; 
      *word++; 
      counter++; 
      int bslashflag = 0; 
     } 
     if(negateornah == 1) { 
      negateornah= 0; //reset flag for next run*/ 
      counter *= -1; //negate the value in counter*/ 
      return counter; 
     } 
     return counter; 
    } 

    else if(iochar == '&') { 
     if (counter ==0) { 
      *word++ = iochar; 
      *word = '\0'; 
      counter++; 
      return counter; 
     } 
     if(bslashflag == 1) { 
      *word = iochar; 
      *word++; 
      counter++; 
      bslashflag = 0; 
     } 
     if(negateornah == 1) { 
      negateornah= 0; /*reset flag for next run*/ 
      counter *= -1; /*negate the value in counter*/ 
      return counter; 
     } 
     return counter; 
    } 

    else if(iochar == '<' || iochar == '>') { 
     if(counter==0){ 
      *word++ = iochar; 
      *word = '\0'; 
      return counter; 
     } 
     if(bslashflag==1) { 
      *word = iochar; 
      *word++; 
      counter++; 
      bslashflag = 0; 
     } 
     if(negateornah == 1) { 
      negateornah= 0; /*reset flag for next run*/ 
      counter *= -1; /*negate the value in counter*/ 
      return counter; 
     } 
     return counter; 

    } 

    else if (iochar == ' ') /* if space is encountered*/ 
    { 
     if(bslashflag == 1){ /* if a backslash was seen before this*/ 
      *word = iochar; 
      *word++; 
      counter++; 
      bslashflag = 0; 
     } 
      else if(counter == 0) /* as the first character */ 
       { 
      while((iochar = getchar()) == ' ') { } /*keep going until*/ 
      } 

     else {     /* iochar is not a space*/ 
        *word = '\0'; /* this block handles the word ending space*/ 

      if(negateornah == 1) { 
      negateornah= 0; /*reset flag for next run*/ 
      counter *= -1; /*negate the value in counter*/ 

      return counter; 
       } 
     return counter; /* by null terminating the word at the end*/ 
     }   /* and returning the count and printed word*/ 
    } 

    *word++ = iochar; /* add iochar into the array if its an alphanum char*/ 
    counter+=1; /* increment counter to reflect added char*/ 
    } 


    *word = '\0'; /* if EOF is encountered*/ 
    *first = '\0'; /* null terminate entire word, clearing it from the array*/ 
    if(counter != 0){ 
     if(negateornah == 1) { 
      negateornah= 0; /*reset flag for next run*/ 
      counter *= -1; /*negate the value in counter*/ 
      return counter; 
     } 
     return counter; /*ensure word continues in next run*/ 
     } 
    return -1;  /*and return -1 for EOF*/ 
} 

Answer 1

最重复的错误似乎是：

*word = iochar; 
    *word++; 

虽然这样做是好的：

*word++ = iochar; 

如果要拆分的两个步骤（集值间接;增量指针）正确的方法是：

*word = iochar; 
    word++; 

下一个重复最多的问题，我看，这并不让你的代码编译和运行，是你只是一个return之前重置局部变量 - 有没有点，一旦你打电话return他们都走了，不会继续下一个电话。

之后，您的缩进风格正在逐渐发展 - 选择一个并坚持使用它。即使你在另一个程序中使用不同的风格，没关系，只要在文件中保持一致。

最后，不要在编译和测试的过程中编写这么多的代码。你永远不应该有这么多错误追踪。当你添加一个新的代码块时，编译和增量测试。

应用上述修补程序和建议以及其他人建议的修复程序，并将代码翻译成C ;-)这里是一个重新编译的返工。这并不意味着它是正确的，只是编译器接受它，以便您可以开始真正的调试：

#include <stdio.h> 
#include <stdbool.h> 
// #include <getword.h> 

int getword(char *w) { 

    char *word = w; /* points to first char in array */ 
    char iochar; /* holds current var being processed */ 
    int counter = 0; /* counts number of characters in a word */ 
    char *first = w; /* points to first character in array */ 
    bool bslashflag = false; /* false if no backslash seen, true otherwise */ 
    bool negateornah = false; /* if true, return value is negated */ 

    while ((iochar = getchar()) != EOF) { /* runs until EOF is encountered */ 

     if (iochar == '\\') { /* if a slash char is found in the word */ 

      bslashflag = true; /* acknowledge that backslash was seen */ 
      iochar = getchar(); /* skip it & go to the next char */ 

      if (iochar == '\\') { /* and if it ends up being another */ 
       /* slash, slash designated to be added in */ 
       *word++ = iochar; /* add it in and go to the next empty slot */ 
       counter++; /* and increment your counter */ 
       iochar = getchar(); /* *ALERT << may or may not be neccessary */ 
      } else if (iochar == '<' || iochar == '>' || iochar == '|' || iochar == '$' || iochar == '&') { 
       /* if a metacharacter is found after a backslash, */ 
       /* just treat it like any other character */ 
       *word++ = iochar; 
       counter++; 
      } 
     } else if (iochar == ' ') { 
      if (counter == 0) { /* if the first char is a space */ 
       while ((iochar = getchar()) == ' ') { 
        /* skip leading blanks */ 
       } 

      } else if (bslashflag) { /* if there was bslash before space */ 
       *word++ = iochar; /* add the space as part of string */ 
       counter++; /* increment counter */ 
       bslashflag = false; /* reset backslash flag for next char check */ 
      } else { /* until alphanum char is found */ 
       *word = '\0'; /* if not leading blank, its the end of word */ 

       if (negateornah) { 
        counter *= -1; /* negate the value in counter */ 
       } 

       return counter; /* return word size */ 
      } 
     } else if (iochar == '\n' || iochar == '<' || iochar == '>' || iochar == '|' || iochar == '$' || iochar == '&') { 
      /* if a metacharacter is encountered */ 

      if (iochar == '\n' && counter == 0) { /* if the first char in the word is \n */ 
       *word = '\0'; /* and null terminate the array; TRY *first INCASE OF ERROR */ 
       if (negateornah) { 
        counter *= -1; /* negate the value in counter */ 
       } 
       return counter; /* null terminate the array and return count so scan can continue */ 

      } else if (iochar == '\n' && counter != 0) { 
       *word = '\0' ; 
       ungetc('\n', stdin); /* put it back where you got it */ 
       if (negateornah) { 
        counter *= -1; /* negate the value in counter */ 
       } 
       return counter; /* and return a number so the scan can continue */ 

      } else if (iochar == '$') { 
       if (counter == 0) { 
        negateornah = true; /* means $ was first char in word, set negate count flag */ 
       } 
       if (bslashflag) { /* if a backslash was seen before this character */ 

        *word++ = iochar; /* just add it into the word as part of the string */ 
        counter++; /* and count it as a letter */ 
       } 
       *word++ = iochar; /* add it into word */ 

       return counter + 1; /* and account for addition */ 

      } else if (iochar == '|') { 
       if (counter == 0) { 
        *word++ = iochar; 
        return counter + 1; 
       } 
       if (bslashflag) { 
        *word++ = iochar; 
        counter++; 
       } 
       if (negateornah) { 
        counter *= -1; /* negate the value in counter */ 
       } 
       return counter; 

      } else if (iochar == '&') { 
       if (counter == 0) { 
        *word++ = iochar; 
        *word = '\0'; 
        return counter + 1; 
       } 
       if (bslashflag) { 
        *word++ = iochar; 
        counter++; 
       } 
       if (negateornah) { 
        counter *= -1; /* negate the value in counter */ 
       } 
       return counter; 

      } else if (iochar == '<' || iochar == '>') { 
       if (counter == 0) { 
        *word++ = iochar; 
        *word = '\0'; 
        return counter; 
       } 
       if (bslashflag) { 
        *word++ = iochar; 
        counter++; 
       } 
       if (negateornah) { 
        counter *= -1; /* negate the value in counter */ 
       } 
       return counter; 

      } else if (iochar == ' ') { /* if space is encountered */ 
       if (bslashflag) { /* if a backslash was seen before this */ 
        *word++ = iochar; 
        counter++; 
        bslashflag = false; 
       } else if (counter == 0) { /* as the first character */ 

        while ((iochar = getchar()) == ' ') { 
         /* keep going until iochar is not a space */ 
        } 
       } else { 
        *word = '\0'; /* this block handles the word ending space */ 

        if (negateornah) { 
         counter *= -1; /* negate the value in counter */ 
        } 
        return counter; /* by null terminating the word at the end */ 
       } /* and return the count and printed word */ 
      } 

      *word++ = iochar; /* add iochar into the array if its an alphanum char */ 
      counter++; /* increment counter to reflect added char */ 
     } 


     *word = '\0'; /* if EOF is encountered */ 
     *first = '\0'; /* null terminate entire word, clearing it from the array */ 

     if (counter != 0) { 
      if (negateornah) { 
       counter *= -1; /* negate the value in counter */ 
      } 
      return counter; 
     } 
    } 

    return -1; /* and return -1 for EOF */ 
}