Quel est le problème avec ce code C de 1988?

J'essaye de compiler ce morceau de code du livre "The C Programming Language" (K & R). Il s'agit d'une version simple du programme 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);
}

Et j'obtiens l'erreur suivante:

$ 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 2ème édition de ce livre date de 1988 et je suis assez nouveau en C. Peut-être que cela a à voir avec la version du compilateur ou peut-être que je dis juste des bêtises.

J'ai vu dans le code C moderne une utilisation différente de la mainfonction:

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

Est-ce une nouvelle norme ou puis-je toujours utiliser un main sans type?

Votre problème concerne vos définitions de préprocesseur de INet OUT:

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

Remarquez comment vous avez un point-virgule de fin dans chacun de ces éléments. Lorsque le préprocesseur les développe, votre code ressemblera à peu près à:

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

Ce deuxième point-virgule fait que le elsen'a aucun précédent ifcomme correspondance, car vous n'utilisez pas d'accolades. Supprimez donc les points-virgules des définitions de préprocesseur de INet OUT.

La leçon apprise ici est que les instructions du préprocesseur ne doivent pas nécessairement se terminer par un point-virgule.

De plus, vous devriez toujours utiliser des accolades!

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

Il n'y a pas d' elseambiguïté suspendue dans le code ci-dessus.

Le principal problème avec ce code est qu'il ne s'agit pas du code de K&R. Il comprend des points-virgules après les définitions de macros, qui n'étaient pas présentes dans le livre, qui, comme d'autres l'ont souligné, modifie la signification.

Sauf lorsque vous effectuez un changement pour tenter de comprendre le code, vous devez le laisser seul jusqu'à ce que vous le compreniez. Vous ne pouvez modifier en toute sécurité que le code que vous comprenez.

Ce n'était probablement qu'une faute de frappe de votre part, mais cela illustre le besoin de compréhension et d'attention aux détails lors de la programmation.

Il ne devrait y avoir aucun point-virgule après les macros,

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

et ça devrait probablement être

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

Les définitions de IN et OUT devraient ressembler à ceci:

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

Les points-virgules causaient le problème! L'explication est simple: IN et OUT sont des directives de préprocesseur, essentiellement le compilateur remplacera toutes les occurrences de IN par un 1 et toutes les occurrences de OUT par un 0 dans le code source.

Étant donné que le code d'origine avait un point-virgule après le 1 et le 0, lorsque IN et OUT ont été remplacés dans le code, le point-virgule supplémentaire après le numéro a produit un code invalide, par exemple cette ligne:

else if (state == OUT)

J'ai fini par ressembler à ceci:

else if (state == 0;)

Mais ce que vous vouliez, c'était ceci:

else if (state == 0)

Solution: supprimez le point-virgule après les nombres dans la définition d'origine.

Comme vous le voyez, il y avait un problème dans les macros.

GCC a la possibilité de s'arrêter après le prétraitement.(-E) Cette option est utile pour voir le résultat du prétraitement. En fait, la technique est importante si vous travaillez avec une grande base de code en c / c ++. En général, les makefiles auront une cible à arrêter après le prétraitement.

Pour une référence rapide: La question SO couvre les options - Comment puis-je voir un fichier source C / C ++ après le prétraitement dans Visual Studio? . Il commence par vc ++, mais a également des options gcc mentionnées ci-dessous .

Pas exactement un problème, mais la déclaration de main()est également datée, cela devrait ressembler à quelque chose comme ça.

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

Le compilateur supposera une valeur de retour int pour une fonction sans une, et je suis sûr que le compilateur / éditeur de liens contournera le manque de déclaration pour argc / argv et le manque de valeur de retour, mais ils devraient être là.

Essayez d'ajouter des accolades explicites autour des blocs de code. Le style K&R peut être ambigu.

Regardez la ligne 18. Le compilateur vous indique où est le problème.

    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 moyen simple consiste à utiliser des crochets comme {} pour chacun ifet else:

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

Comme d'autres réponses l'ont souligné, le problème est entre les #definepoints et les points-virgules. Pour minimiser ces problèmes, je préfère toujours définir les constantes numériques comme const int:

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

De cette façon, vous vous débarrassez de nombreux problèmes et problèmes éventuels. Il est limité par seulement deux choses:

1. Votre compilateur doit prendre en charge const- ce qui n'était généralement pas vrai en 1988, mais maintenant il est pris en charge par tous les compilateurs couramment utilisés. (AFAIK le constest "emprunté" à C ++.)

2. Vous ne pouvez pas utiliser ces constantes dans certains endroits spéciaux où vous auriez besoin d'une constante de type chaîne. Mais je pense que votre programme n'est pas ce cas.