Cosa c'è di sbagliato in questo codice C del 1988?

Sto cercando di compilare questo pezzo di codice dal libro "The C Programming Language" (K & R). È una versione ridotta all'osso del programma UNIX wc:

#include <stdio.h>

#define IN   1;     /* inside a word */
#define OUT  0;     /* outside a word */

/* count lines, words and characters in input */
main()
{
    int c, nl, nw, nc, state;

    state = OUT;
    nl = nw = nc = 0;
    while ((c = getchar()) != EOF) {
        ++nc;
        if (c == '\n')
            ++nl;
        if (c == ' ' || c == '\n' || c == '\t')
            state = OUT;
        else if (state == OUT) {
            state = IN;
            ++nw;
        }
    }
    printf("%d %d %d\n", nl, nw, nc);
}

E ricevo il seguente errore:

$ gcc wc.c 
wc.c: In function ‘main’:
wc.c:18: error: ‘else’ without a previous ‘if’
wc.c:18: error: expected ‘)’ before ‘;’ token

La seconda edizione di questo libro è del 1988 e sono abbastanza nuovo per C. Forse ha a che fare con la versione del compilatore o forse sto solo dicendo sciocchezze.

Ho visto nel codice C moderno un uso diverso della mainfunzione:

int main()
{
    /* code */
    return 0;
}

È un nuovo standard o posso ancora utilizzare un main senza tipo?

Il tuo problema è con le definizioni del tuo preprocessore di INe OUT:

#define IN   1;     /* inside a word */
#define OUT  0;     /* outside a word */

Nota come hai un punto e virgola finale in ciascuno di questi. Quando il preprocessore li espande, il tuo codice apparirà più o meno come:

    if (c == ' ' || c == '\n' || c == '\t')
        state = 0;; /* <--PROBLEM #1 */
    else if (state == 0;) { /* <--PROBLEM #2 */
        state = 1;;

Quel secondo punto e virgola fa sì che il elsenon abbia precedenti ifcome corrispondenza, perché non stai usando le parentesi graffe. Quindi, rimuovere i punti e virgola dalle definizioni del preprocessore di INe OUT.

La lezione appresa qui è che le istruzioni del preprocessore non devono terminare con un punto e virgola.

Inoltre, dovresti sempre usare le parentesi graffe!

    if (c == ' ' || c == '\n' || c == '\t') {
        state = OUT;
    } else if (state == OUT) {
        state = IN;
        ++nw;
    }

Non ci sono elseambiguità sospese nel codice precedente.

Il problema principale di questo codice è che è non il codice da K & R. Include il punto e virgola dopo le definizioni delle macro, che non erano presenti nel libro, che come altri hanno sottolineato cambia il significato.

Tranne quando si effettua una modifica nel tentativo di comprendere il codice, è necessario lasciarlo in pace finché non lo si capisce. Puoi modificare in sicurezza solo il codice che conosci.

Questo probabilmente è stato solo un errore di battitura da parte tua, ma illustra la necessità di comprensione e attenzione ai dettagli durante la programmazione.

Non dovrebbero esserci punti e virgola dopo le macro,

#define IN   1     /* inside a word */
#define OUT  0     /* outside a word */

e probabilmente dovrebbe esserlo

if (c == ' ' || c == '\n' || c == '\t')

Le definizioni di IN e OUT dovrebbero assomigliare a questa:

#define IN   1     /* inside a word  */
#define OUT  0     /* outside a word */

Il punto e virgola stava causando il problema! La spiegazione è semplice: sia IN che OUT sono direttive del preprocessore, essenzialmente il compilatore sostituirà tutte le occorrenze di IN con un 1 e tutte le occorrenze di OUT con uno 0 nel codice sorgente.

Poiché il codice originale aveva un punto e virgola dopo l'1 e lo 0, quando IN e OUT venivano sostituiti nel codice, il punto e virgola in più dopo il numero produceva un codice non valido, ad esempio questa riga:

else if (state == OUT)

Finì per assomigliare a questo:

else if (state == 0;)

Ma quello che volevi era questo:

else if (state == 0)

Soluzione: rimuovere il punto e virgola dopo i numeri nella definizione originale.

Come vedi c'era un problema nelle macro.

GCC ha l'opzione per l' arresto dopo la pre-elaborazione.(-E) Questa opzione è utile per vedere il risultato della pre-elaborazione. In effetti la tecnica è importante se stai lavorando con una grande base di codice in c / c ++. Tipicamente i makefile avranno un obiettivo da fermare dopo la pre-elaborazione.

Per riferimento rapido: la domanda SO copre le opzioni: come faccio a visualizzare un file sorgente C / C ++ dopo la pre-elaborazione in Visual Studio? . Inizia con vc ++, ma ha anche le opzioni gcc menzionate di seguito .

Non è esattamente un problema, ma anche la dichiarazione di main()è datata, dovrebbe essere qualcosa del genere.

int main(int argc, char** argv) {
    ...
    return 0;
}

Il compilatore assumerà un valore di ritorno int per una funzione senza uno, e sono sicuro che il compilatore / linker aggirerà la mancanza di dichiarazione per argc / argv e la mancanza di valore di ritorno, ma dovrebbero essere lì.

Prova ad aggiungere parentesi graffe esplicite attorno ai blocchi di codice. Lo stile K&R può essere ambiguo.

Guarda la riga 18. Il compilatore ti sta dicendo dov'è il problema.

    if (c == '\n') {
        ++nl;
    }
    if (c == ' ' || c == '\n' || c == '\t') { // You're missing an "=" here; should be "=="
        state = OUT;
    }
    else if (state == OUT) {
        state = IN;
        ++nw;
    }

Un modo semplice è usare parentesi come {} per ciascuno ife else:

if (c == '\n'){
    ++nl;
}
if (c == ' ' || c == '\n' || c == '\t')
{
    state = OUT;
}
else if (state == OUT) {
    state = IN;
    ++nw;
}

Come sottolineato da altre risposte, il problema è in #definee punto e virgola. Per ridurre al minimo questi problemi preferisco sempre definire le costanti numeriche come const int:

const int IN = 1;
const int OUT = 0;

In questo modo elimini molti problemi e possibili problemi. È limitato da due sole cose:

1. Il tuo compilatore deve supportare const, cosa che nel 1988 non era generalmente vera, ma ora è supportata da tutti i compilatori comunemente usati. (AFAIK il constè "preso in prestito" da C ++.)

2. Non puoi usare queste costanti in alcuni punti speciali in cui avresti bisogno di una costante simile a una stringa. Ma penso che il tuo programma non sia questo il caso.