Syntaxe du C : la structure d'un programme C expliquée

Le C a très peu de syntaxe à apprendre - environ 32 mots-clés et une poignée de règles de ponctuation. Presque tous les programmes que vous écrirez ont la même forme extérieure, il vaut donc la peine de démonter cette forme une fois, soigneusement.

Le plus petit programme complet

Ceci compile, s'exécute et ne fait rien :

int main(void) {
    return 0;
}

Aucune inclusion, aucune sortie, aucune classe ni module obligatoire. main est le point d'entrée : quand le système d'exploitation démarre votre programme, il appelle main. Quand main retourne, le programme se termine, et la valeur renvoyée est le code de sortie.

Ajoutez de la sortie et il vous faut une inclusion :

#include <stdio.h>

int main(void) {
    printf("Bonjour, C !\n");
    return 0;
}

Les directives du préprocesseur

Les lignes commençant par # sont traitées avant la compilation proprement dite, par le préprocesseur. Ce ne sont pas des instructions C, et elles ne prennent aucun point-virgule.

#include <stdio.h>    /* en-tete de la bibliotheque standard - chevrons */
#include "myutils.h"  /* votre propre en-tete - guillemets, cherche d'abord localement */
#define MAX 100       /* une macro - MAX est remplace par 100 partout en dessous */

#include est un collage de texte littéral : tout le contenu du fichier nommé est déposé à cet endroit. stdio.h contient la déclaration de printf, c'est ainsi que le compilateur sait quels arguments printf prend. Omettez l'inclusion et vous obtenez implicit declaration of function 'printf'.

La distinction chevrons contre guillemets porte sur l'endroit où le compilateur cherche : <...> désigne les répertoires d'inclusion du système, "..." signifie « regarde d'abord à côté de ce fichier ».

La fonction main

int main(void) {
    return 0;
}

Quatre parties, toutes chargées de sens :

• int - le type de retour de main. La valeur part vers le système d'exploitation comme code de sortie, où 0 signifie succès.
• main - le nom réservé que l'environnement d'exécution appelle. Tout programme C hébergé en a exactement un.
• (void) - la liste de paramètres. void signifie ici « ne prend aucun argument ». Écrire main() est légal mais plus faible : des parenthèses vides en C signifient « paramètres non spécifiés », ce qui désactive la vérification des arguments.
• { ... } - le corps de la fonction.

L'autre forme standard prend les arguments de ligne de commande :

int main(int argc, char *argv[]) { ... }

Utilisez int main(void) jusqu'à ce que vous en ayez besoin.

Instructions et points-virgules

Une instruction est une consigne unique, et elle se termine par un point-virgule.

#include <stdio.h>

int main(void) {
    int a = 5;
    int b = 7;
    int sum = a + b;
    printf("%d + %d = %d\n", a, b, sum);
    return 0;
}

Quatre instructions, quatre points-virgules. Le point-virgule est un terminateur, pas un séparateur - la dernière instruction d'un bloc en a besoin aussi.

Ce qui ne prend pas de point-virgule :

#include <stdio.h>        /* ligne du preprocesseur - pas de point-virgule */

int add(int a, int b) {   /* en-tete de definition de fonction - pas de point-virgule */
    return a + b;
}                         /* accolade fermante d'une fonction - pas de point-virgule */

if (x > 0) {
    ...
}                         /* accolade fermante d'un bloc de controle - pas de point-virgule */

Le cas qui piège tout le monde est un point-virgule là où devrait se trouver un corps :

if (score > 90);              /* BUG: ce ; est tout le corps du if */
    printf("Excellent !\n");  /* s'execute toujours, quel que soit score */

C'est du C parfaitement légal. Le if contrôle une instruction vide, et le printf n'est que la ligne suivante dans l'ordre. -Wall le signale ; le compilateur ne vous arrêtera pas.

Blocs et accolades

Les accolades regroupent des instructions en un bloc, qui compte pour une seule instruction partout où une instruction est attendue.

#include <stdio.h>

int main(void) {
    int temp = 35;

    if (temp > 30) {
        printf("Il fait chaud.\n");
        printf("Buvez de l'eau.\n");
    }

    return 0;
}

Les accolades sont facultatives quand le corps est une instruction unique, mais les omettre est la source des bugs célèbres - ajoutez une seconde ligne plus tard et elle sort silencieusement du if. Mettez toujours des accolades.

Les blocs créent aussi une portée : une variable déclarée dans { ... } cesse d'exister à l'accolade fermante.

#include <stdio.h>

int main(void) {
    int outer = 1;

    {
        int inner = 2;
        printf("dedans : outer=%d inner=%d\n", outer, inner);
    }

    /* inner n'existe pas ici */
    printf("dehors : outer=%d\n", outer);
    return 0;
}

Sensibilité à la casse et espaces

Le C est sensible à la casse partout. total, Total et TOTAL sont trois noms distincts. Tous les mots-clés sont en minuscules, donc Int, Return et Printf sont tous des erreurs - et le message d'erreur pour Printf est déroutant, car le compilateur suppose que vous vouliez une fonction dont il n'a jamais entendu parler.

Les espaces, en revanche, sont presque entièrement libres. Le compilateur traite toute suite d'espaces, de tabulations et de sauts de ligne comme un seul séparateur. Ceci est valide :

int    main ( void )
{
    printf
    ( "Bonjour\n" ) ;
    return 0 ;
}

Et ceci aussi :

int main(void){printf("Bonjour\n");return 0;}

Les deux compilent à l'identique. Puisque le compilateur s'en moque, la mise en forme est entièrement pour les humains - et la disposition conventionnelle (une instruction par ligne, quatre espaces ou une tabulation par niveau d'imbrication, accolade ouvrante sur la même ligne) mérite d'être suivie, car toutes les bases de code C que vous lirez utiliseront quelque chose d'approchant.

Deux endroits où les espaces comptent : vous ne pouvez pas couper un mot-clé ou un identifiant (in t n'est pas int), et vous ne pouvez pas mettre un saut de ligne dans un littéral de chaîne ordinaire.

Les identifiants : règles de nommage

Un identifiant est n'importe quel nom que vous choisissez - variables, fonctions, types. Les règles :

• Composé de lettres, de chiffres et de tirets bas.
• Ne doit pas commencer par un chiffre. total2 convient, 2total non.
• Ne peut pas être un mot-clé : pas de variable appelée int, for ou return.
• La casse compte.
• Les noms commençant par un tiret bas, et tout ce qui comporte deux tirets bas à la suite, sont réservés à l'implémentation - n'en inventez pas.

int score;        /* bien */
int total_items;  /* bien - snake_case est la convention C */
int _hidden;      /* legal mais reserve - a eviter */
int 2fast;        /* erreur */
int float;        /* erreur - mot-cle */

Un programme entièrement annoté

Tout ce qui précède, au même endroit :

#include <stdio.h>          /* apporte printf */

#define TAX_RATE 0.08       /* une constante de compilation */

/* Une definition de fonction : type de retour, nom, parametres, corps. */
double with_tax(double price) {
    return price + price * TAX_RATE;
}

int main(void) {            /* l'execution commence ici */
    double item = 25.0;     /* declaration + initialisation */
    double total;           /* declaration seule */

    total = with_tax(item); /* appel de la fonction, affectation du resultat */

    /* %.2f affiche un double avec deux decimales */
    printf("Article : %.2f\n", item);
    printf("Total   : %.2f\n", total);

    if (total > 25.0) {     /* un bloc controle par une condition */
        printf("La taxe a ete appliquee.\n");
    }

    return 0;               /* code de sortie : succes */
}

L'ordre de lecture compte ici : with_tax est défini avant que main l'utilise. Le C lit le fichier de haut en bas, donc une fonction doit être déclarée avant d'être appelée. Définissez-la plus tôt, ou écrivez un prototype de fonction en haut et définissez-la plus loin.