Extraneous Fehler? Wo und was sind sie? C Programmierung

Question

mein Code wurde wiederholt Korrektur gelesen und ich bin immer noch nicht in der Lage herauszufinden, warum einige dieser Zeilen Fehlermeldungen ausgeben. Zeilen mit nur einem '}' werden als Fehler ausgegeben. Wie ist das möglich?

#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

Die wiederholten Fehler scheint zu sein:

*word = iochar; 
    *word++; 

Obwohl dies zu tun ist in Ordnung:

*word++ = iochar; 

Wenn Sie die zwei Schritte geteilt werden soll (set Wert indirekt, Zeiger inkrementieren) ist der richtige Weg zu tun:

*word = iochar; 
    word++; 

Die nächste wiederholten Frage, die ich sehen, was Ihr Code hält nicht kompilieren oder ausgeführt wird, ist, dass man kurz vor einer return lokalen Variablen zurückgesetzt - es hat keinen Sinn, wenn Sie return sie alle nennen gegangen und wird nicht zum nächsten Anruf übergehen.

Danach steht Ihnen Ihr Eindrucks-Stil im Weg - wählen Sie einen und bleiben Sie dabei steif. Selbst wenn Sie einen anderen Stil in einem anderen Programm verwenden, ist das in Ordnung, nur innerhalb der Datei konsistent sein.

Schließlich schreiben Sie nicht so viel Code ohne kompilieren und testen auf dem Weg. Sie sollten nie in der Lage sein, so viele Fehler aufzuspüren. Wenn Sie einen neuen Codeblock hinzufügen, kompilieren und inkrementell testen.

Anwenden der oben genannten Fixes und Vorschläge, sowie von anderen vorgeschlagenen Korrekturen und Übersetzen Ihres Codes in C ;-) Hier ist eine Überarbeitung, die kompiliert. Es bedeutet nicht, es richtig ist, einfach, dass der Compiler akzeptiert ausreichend, dass Sie die realen Debuggen starten:

#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 */ 
}