LANGAGE C : LES BASES, GROUPE GENIUS

Ce cours pose les fondations du langage C et rien d'autre : comment un programme est fabriqué, comment il est structuré, comment on déclare des données, comment on calcule, comment on affiche et comment on lit une saisie. Tout y est détaillé, schémas à l'appui, avec quinze questions de cours et trente et un exercices corrigés.

Ce que vous saurez faire à la fin

• Expliquer ce qui se passe entre votre fichier .c et le programme qui s'exécute, étape par étape.
• Écrire, compiler et exécuter un programme, et lire un message d'erreur pour savoir quelle étape se plaint.
• Choisir le bon type de données et prévoir ce qu'il peut contenir.
• Maîtriser printf au caractère près, et scanf sans tomber dans ses deux pièges classiques.
• Reconnaître les erreurs de débutant avant qu'elles ne vous coûtent une soirée.

À qui s'adresse ce cours

À toute personne qui n'a jamais écrit une ligne de C, ou qui l'a appris trop vite et veut reprendre des bases solides. Aucune connaissance préalable n'est supposée.

Tous les affichages montrés dans ce cours ont été vérifiés par le calcul avant publication : tailles de types, étendues, arrondis de printf, résultats de division entière.

1. Comprendre ce qu'est le C avant d'en écrire

Le C a été créé en 1972 par Dennis Ritchie, dans les laboratoires Bell, pour écrire le système d'exploitation Unix. Plus de cinquante ans plus tard, il est toujours là, et pas par nostalgie.

Le noyau de Linux est écrit en C. Celui de Windows aussi, en grande partie. Les bibliothèques qui font tourner Python, PHP et Java sont écrites en C. Le programme qui pilote le capteur d'un téléphone, la puce d'une carte bancaire ou le calculateur d'un véhicule : en C.

La raison tient en une phrase : le C vous laisse voir la machine. Là où d'autres langages vous protègent derrière une couche d'abstraction, le C vous met devant la mémoire, les octets et les types. C'est plus exigeant. C'est aussi ce qui en fait le meilleur langage pour comprendre ce qu'un ordinateur fait réellement.

Un langage compilé : ce que cela change

Il existe deux grandes familles de langages, et la différence se voit dès le premier programme.

Un langage interprété, comme Python, est lu et exécuté ligne par ligne par un autre programme appelé interpréteur. Vous écrivez, vous lancez, ça tourne. Pratique, mais il faut que l'interpréteur soit installé sur la machine, et le programme est plus lent.

Un langage compilé, comme le C, est d'abord traduit entièrement en instructions que le processeur comprend directement. Cette traduction produit un fichier exécutable autonome. Le programme démarre plus vite, tourne plus vite, et n'a besoin de rien d'autre pour fonctionner.

Un programme C n'est pas lu par la machine : il est traduit une fois pour toutes dans la langue de la machine, puis exécuté.

Cela a une conséquence immédiate : vous ne pouvez pas exécuter un programme qui contient une faute. Le compilateur refuse de traduire et vous signale l'erreur. C'est pénible au début, et c'est un cadeau : la moitié des bogues sont attrapés avant même que le programme ne tourne.

Autre conséquence : le fichier produit ne fonctionne que sur le type de machine pour lequel il a été compilé. Un programme compilé sous Windows ne tourne pas tel quel sous Linux. Le code source, lui, est le même partout : il suffit de le recompiler.

Ce dont vous avez besoin

• Un éditeur de texte : Visual Studio Code, Code::Blocks, Notepad++, ou même le Bloc-notes. Pas un traitement de texte : Word ajoute de la mise en forme invisible qui casse tout.
• Un compilateur : gcc est le plus répandu. Sous Windows on l'installe avec MinGW-w64 ou MSYS2 ; sous Linux il est souvent déjà présent ; sous macOS il arrive avec les outils Xcode.
• Un terminal : pour lancer la compilation et voir les messages d'erreur. C'est là que tout se passe.

Un fichier source C porte l'extension .c. Pas .txt, pas .c.txt : .c. C'est une erreur de débutant classique sous Windows, où l'explorateur cache les extensions.

2. De votre fichier au programme : la chaîne de compilation

Quand vous tapez gcc bonjour.c -o bonjour, il ne se passe pas une chose, mais quatre. Les connaître vous fera gagner des heures le jour où un message d'erreur sera incompréhensible : parce que vous saurez quelle étape se plaint.

Étape 1 : Le préprocesseur

Avant toute traduction, un programme appelé préprocesseur relit votre fichier et traite toutes les lignes qui commencent par un dièse #. Il ne comprend rien au C : il fait du copier-coller et du remplacement de texte.

Il recopie le contenu des fichiers demandés par #include, remplace les constantes définies par #define, et supprime les commentaires. Le résultat est un fichier C « à plat », sans aucune directive. On peut le voir avec gcc -E bonjour.c : attendez-vous à plusieurs milliers de lignes, car stdio.h est volumineux.

Étape 2 : Le compilateur

C'est l'étape que l'on appelle « compilation » au sens strict. Le compilateur analyse le C, vérifie la syntaxe et les types, puis traduit en assembleur : un langage très proche du processeur, mais encore lisible par un humain.

C'est ici que naissent la plupart des messages d'erreur : point-virgule oublié, variable non déclarée, type incompatible.

Étape 3 : L'assembleur

L'assembleur traduit le texte assembleur en code machine : des octets que le processeur exécute directement. Le résultat est un fichier objet, d'extension .o (ou .obj sous Windows). Cette étape échoue très rarement.

Étape 4 : L'éditeur de liens

Votre fichier objet contient votre code, mais pas celui de printf. L'éditeur de liens va chercher ce code dans les bibliothèques du système, le rattache au vôtre, et produit enfin le programme exécutable.

Compiler en pratique

gcc bonjour.c -o bonjour        # produit le programme « bonjour »
./bonjour                       # l'exécute sous Linux ou macOS
bonjour.exe                     # l'exécute sous Windows

Trois options méritent d'être prises comme une habitude dès le premier jour :

gcc -Wall -Wextra -std=c17 bonjour.c -o bonjour

• -Wall et -Wextra activent les avertissements. Ce ne sont pas des erreurs : le programme compile quand même. Mais un avertissement signale presque toujours un vrai problème. Traitez-les comme des erreurs.
• -std=c17 fixe la version de la norme utilisée, pour que votre programme se comporte pareil chez tout le monde.

Un programme qui compile sans avertissement n'est pas forcément juste. Un programme qui compile avec des avertissements est presque toujours faux.

3. La structure d'un programme C

Voici le programme le plus court qui fasse quelque chose d'utile. Chaque ligne a un rôle précis, et nous allons les prendre une par une.

#include <stdio.h>

int main(void)
{
    int age = 20;
    printf("J'ai %d ans\n", age);
    return 0;
}

La ligne #include <stdio.h>

Le C de base ne sait rien faire : il ne sait ni afficher, ni lire, ni calculer une racine carrée. Tout cela vient de bibliothèques.

stdio.h signifie standard input/output : entrées et sorties standard. C'est le fichier qui décrit printf et scanf. Sans cette ligne, le compilateur ne sait pas ce qu'est printf et refuse de continuer.

Notez l'absence de point-virgule. Une directive du préprocesseur n'est pas une instruction C : elle s'arrête à la fin de la ligne.

La ligne int main(void)

C'est le point d'entrée du programme. Quand le système lance votre exécutable, il cherche main et commence là. Un programme C sans main ne peut pas démarrer.

• int annonce que main renvoie un entier au système en se terminant.
• main est le nom imposé par la norme. Ni Main, ni principal.
• (void) signifie « ce programme ne reçoit aucun argument ». On peut en recevoir, mais ce n'est pas le sujet ici.

Les accolades

L'accolade ouvrante { et l'accolade fermante } délimitent le corps de main : tout ce que le programme doit faire. Elles vont toujours par paire.

Entre les deux, on indente : quatre espaces, ou une tabulation. Le compilateur s'en moque complètement : il lirait tout aussi bien un programme écrit sur une seule ligne. L'indentation est pour les humains, et elle n'est pas optionnelle : un code mal indenté est un code où les erreurs se cachent.

Les instructions et le point-virgule

Chaque instruction se termine par un point-virgule. C'est lui qui dit « cette instruction est finie », et non le retour à la ligne.

int age = 20;              /* une instruction */
printf("Bonjour\n");       /* une autre */

Le point-virgule oublié est l'erreur numéro un du débutant. Elle est d'autant plus déroutante que le compilateur signale souvent la ligne suivante : il continue de lire, croit que l'instruction se poursuit, et ne comprend qu'au mot d'après. Quand une erreur vous paraît absurde, regardez la ligne du dessus.

Les commentaires

/* un commentaire
   sur plusieurs lignes */

// un commentaire jusqu'à la fin de la ligne

Le préprocesseur les efface : ils ne coûtent rien à l'exécution. Écrivez-y pourquoi vous faites quelque chose, pas ce que vous faites : le code le dit déjà.

La ligne return 0;

Elle termine main et renvoie 0 au système d'exploitation. Par convention universelle : 0 signifie que tout s'est bien passé, toute autre valeur signale une erreur.

Ce n'est pas décoratif. Les scripts et les outils d'automatisation lisent ce code de retour pour savoir si votre programme a réussi.

4. Les directives du préprocesseur

Toutes les lignes qui commencent par # s'adressent au préprocesseur, pas au compilateur. Il faut bien comprendre ce qu'il fait : du remplacement de texte, et rien d'autre. Il ne vérifie aucun type, il ne calcule rien, il ne comprend pas le C.

#include : aller chercher du code ailleurs

Cette directive remplace la ligne par le contenu entier du fichier désigné. Il existe deux écritures, et elles ne cherchent pas au même endroit.

#include <stdio.h>      /* chevrons : les bibliotheques du systeme */
#include "mes_outils.h"  /* guillemets : d'abord a cote de mon fichier */

Les fichiers d'en-tête les plus utiles au début :

#define : donner un nom à une valeur

#define PI 3.14159265
#define TVA 0.1925
#define NOM_ECOLE "Groupe Genius"

Partout où le préprocesseur rencontre PI, il écrit 3.14159265 à la place. Le compilateur ne verra jamais le mot PI.

Pas de point-virgule à la fin, sinon il serait recopié lui aussi, ce qui produit des erreurs incompréhensibles.

L'usage veut qu'on écrive ces noms en majuscules. Ce n'est pas une obligation du langage, mais cela permet de reconnaître au premier coup d'œil ce qui est remplacé par le préprocesseur.

Les macros, et le piège des parenthèses

Un #define peut prendre des paramètres :

#define DOUBLE(x) x * 2

Écrivez DOUBLE(3) : le préprocesseur produit 3 * 2, soit 6. Parfait. Maintenant écrivez DOUBLE(2 + 1) :

DOUBLE(2 + 1)   devient   2 + 1 * 2   qui vaut   4

On attendait 6. Le préprocesseur a remplacé bêtement, et la priorité de la multiplication a fait le reste. La parade est de tout parenthéser :

#define DOUBLE(x) ((x) * 2)

DOUBLE(2 + 1)   devient   ((2 + 1) * 2)   qui vaut   6

Dans une macro, chaque paramètre va entre parenthèses, et l'expression entière aussi. Toujours.

#ifdef et les gardes d'inclusion

Le préprocesseur sait aussi inclure ou non une portion de code :

#define DEBUG

#ifdef DEBUG
    printf("valeur intermediaire : %d\n", x);
#endif

Si DEBUG est défini, la ligne existe ; sinon elle disparaît avant même la compilation. C'est ainsi qu'on laisse des traces de mise au point sans ralentir le programme final.

La variante #ifndef (« si ce n'est pas défini ») sert aux gardes d'inclusion, qui empêchent un même fichier d'être inclus deux fois :

#ifndef MES_OUTILS_H
#define MES_OUTILS_H

/* le contenu du fichier */

#endif

5. Les types de données

En C, toute donnée a un type, déclaré à l'avance. Ce n'est pas une formalité administrative : le type décide de trois choses à la fois.

• Combien de place la donnée occupe en mémoire.
• Comment les octets doivent être interprétés : le même motif binaire ne vaut pas la même chose selon qu'on le lit comme un entier ou comme un flottant.
• Quelles opérations ont un sens, et comment elles se comportent.

Les entiers

int est le type de travail par défaut : c'est celui que le processeur manipule le plus vite. Prenez-le, sauf raison précise de faire autrement.

signed et unsigned

Par défaut, les entiers sont signés : ils peuvent être négatifs, au prix d'un bit consacré au signe. En ajoutant unsigned, on renonce aux négatifs et on double l'étendue positive.

int          n;    /* -2 147 483 648 a 2 147 483 647 */
unsigned int m;    /*             0 a 4 294 967 295  */

À réserver aux quantités qui ne peuvent pas être négatives : une taille, un compteur, une adresse. Et attention : mélanger signé et non signé dans un même calcul produit des résultats surprenants. En cas de doute, restez en signé.

Les nombres à virgule

Les deux suivent la norme IEEE 754 : un bit de signe, un exposant, une mantisse. float dispose de 23 bits de mantisse, double de 52 : d'où la différence de précision.

Prenez double par défaut. Le float ne garantit que sept chiffres, et ils s'épuisent vite.

Un détail qui surprend : un nombre écrit 3.5 dans le code source est un double. Pour obtenir un float, il faut écrire 3.5f.

Le caractère : un entier déguisé

Le type char stocke un caractère… sous la forme d'un nombre. C'est son code ASCII.

char lettre = 'A';
printf("%c\n", lettre);    /* affiche  A  */
printf("%d\n", lettre);    /* affiche  65 */

Même case mémoire, deux façons de la lire. Cela autorise de l'arithmétique sur les caractères : 'a' - 'A' vaut 32, et '7' - '0' vaut 7, c'est ainsi qu'on convertit un chiffre caractère en chiffre nombre.

Attention aux quotes : 'A' avec des apostrophes simples est un caractère ; "A" avec des guillemets est une chaîne. Ce ne sont pas les mêmes choses, et le compilateur le dira.

L'opérateur sizeof

printf("un int occupe %zu octets\n", sizeof(int));
printf("un double occupe %zu octets\n", sizeof(double));

sizeof répond en octets. Le marqueur %zu est celui qui convient à son type de retour. C'est la seule façon fiable de connaître les tailles sur votre machine.

Les conversions

Quand deux types se rencontrent dans un calcul, le C convertit automatiquement, et c'est là que les surprises arrivent.

printf("%d\n",  5 / 2);       /* affiche 2   : deux entiers, division entiere */
printf("%f\n",  5 / 2.0);     /* affiche 2.500000 : un double, division reelle */
printf("%f\n",  (float)5 / 2); /* affiche 2.500000 : conversion explicite */

Deux entiers donnent toujours une division entière. La partie décimale est jetée, pas arrondie. 7 / 2 vaut 3, et 1 / 3 vaut 0.

Le piège classique :

double moyenne = 5 / 2;      /* moyenne vaut 2.0, pas 2.5 ! */

La division est faite avant l'affectation, entre deux entiers. La conversion en double arrive trop tard.

La conversion explicite, ou cast, s'écrit en mettant le type voulu entre parenthèses :

int somme = 17, nombre = 5;
double moyenne = (double)somme / nombre;   /* 3.4, correct */

Dans l'autre sens, convertir un flottant en entier tronque, il n'arrondit pas : (int)3.99 vaut 3, et (int)-3.99 vaut −3.

6. Les variables

Une variable est une case de la mémoire à laquelle on a donné un nom et un type. Le nom vous évite de manipuler des adresses ; le type dit à la machine comment lire le contenu de la case.

Déclarer, initialiser

int age;              /* declaration seule : la case existe, son contenu est inconnu */
age = 20;             /* affectation : on y range 20 */

int annee = 2026;     /* declaration et initialisation en une fois */

int x = 1, y = 2, z;  /* trois variables du meme type sur une ligne */

La deuxième forme est préférable : une variable déclarée et initialisée d'un seul geste ne peut pas être utilisée par erreur avant d'avoir une valeur.

int total;
printf("%d\n", total);   /* affiche n'importe quoi */

Les règles de nommage

• Lettres, chiffres et tiret bas _ uniquement. Pas d'espace, pas de tiret, pas d'accent.
• Le premier caractère ne peut pas être un chiffre.
• Les majuscules comptent : age, Age et AGE sont trois variables différentes.
• Un mot réservé du langage est interdit.

Les 32 mots réservés du C de base, qu'aucune variable ne peut porter :

auto     break    case     char     const    continue default  do
double   else     enum     extern   float    for      goto     if
int      long     register return   short    signed   sizeof   static
struct   switch   typedef  union    unsigned void     volatile while

Donnez des noms qui parlent. prix_unitaire vaut mieux que pu, et bien mieux que a. Vous relirez ce code dans six mois.

const et #define

Deux façons de dire « cette valeur ne doit pas changer ».

#define TAUX_TVA 0.1925        /* le preprocesseur remplace le texte */
const double taux_tva = 0.1925; /* une vraie variable, en lecture seule */

Préférez const : il a un type, donc le compilateur peut vous protéger. Gardez #define pour ce qui n'est pas une valeur : des options de compilation, des bouts de texte.

Dans les deux cas, toute tentative de modification est refusée :

const double taux_tva = 0.1925;
taux_tva = 0.2;   /* erreur : assignment of read-only variable */

7. Les opérateurs

Les opérateurs arithmétiques

Le modulo % ne fonctionne qu'entre entiers : jamais sur des flottants. Il est bien plus utile qu'il n'en a l'air : associé à la division entière, il permet de décomposer un nombre.

int n = 4729;
printf("%d %d %d %d\n",
       n / 1000,          /* 4  : les milliers  */
       (n / 100) % 10,    /* 7  : les centaines */
       (n / 10) % 10,     /* 2  : les dizaines  */
       n % 10);           /* 9  : les unites    */

-7 / 2  vaut -3        -7 % 2  vaut -1
 7 / -2 vaut -3         7 % -2 vaut  1

L'affectation, et ses raccourcis

int total = 100;

total = total + 50;    /* la forme longue */
total += 50;           /* exactement la meme chose */

total -= 20;     /*  total = total - 20  */
total *= 2;      /*  total = total * 2   */
total /= 4;      /*  total = total / 4   */
total %= 7;      /*  total = total % 7   */

Le signe = n'est pas une égalité mathématique. Il se lit « reçoit » : total = total + 50 signifie « calcule total + 50 et range le résultat dans total ».

Incrémentation et décrémentation

int i = 5;
i++;     /* i vaut maintenant 6 */
i--;     /* i vaut de nouveau 5 */

Les deux écritures i++ et ++i augmentent i de 1. La différence porte sur la valeur de l'expression elle-même, quand on l'utilise dans un calcul.

int i = 5, a, b;

a = i++;    /* a recoit 5, PUIS i passe a 6   (post-incrementation) */

i = 5;
b = ++i;    /* i passe a 6, PUIS b recoit 6   (pre-incrementation)  */

Tant que vous écrivez i++; seul sur sa ligne, les deux formes sont interchangeables. C'est en les mêlant à une expression qu'il faut être précis.

Un avertissement. N'écrivez jamais une expression où la même variable est modifiée deux fois, comme i = i++ + ++i;. Le résultat n'est pas défini par la norme : chaque compilateur peut donner une réponse différente, et aucune n'est fautive.

Comparaison et logique

Ces opérateurs appartiennent au cours sur les structures conditionnelles, mais il faut savoir dès maintenant ce qu'ils produisent : un entier, 0 ou 1. Le C n'a pas de type booléen de base.

On peut donc afficher le résultat d'une comparaison :

printf("%d\n", 10 > 3);   /* affiche 1 */
printf("%d\n", 10 == 3);  /* affiche 0 */

Ne confondez jamais = (affectation) et == (comparaison). C'est la faute la plus coûteuse du C, car elle compile sans erreur.

Les priorités

De la plus forte à la plus faible, pour ce qui nous concerne ici :

2 + 3 * 4      vaut 14    (la multiplication d'abord)
(2 + 3) * 4    vaut 20
10 % 3 * 2     vaut  2    (% et * ont le meme rang, lecture de gauche a droite)
10 - 4 - 3     vaut  3    (gauche a droite : (10-4)-3)

Le conseil le plus utile de cette section : mettez des parenthèses. Elles ne coûtent rien à l'exécution et elles vous dispensent d'apprendre ce tableau par cœur.

8. Afficher avec printf

printf vient de print formatted : afficher en respectant un format. C'est la fonction que vous appellerez le plus souvent, et elle mérite qu'on s'y arrête.

Le principe

Son premier argument est une chaîne de format : du texte dans lequel certains endroits sont marqués par un %. Les arguments qui suivent viennent remplir ces marques, dans l'ordre.

printf("Bonjour Awa, tu as 17 ans.\n");          /* sans marqueur */

int age = 17;
printf("Bonjour Awa, tu as %d ans.\n", age);     /* un marqueur */

Les marqueurs de conversion

Largeur, précision, alignement

Entre le % et la lettre, on peut glisser des réglages. La forme complète est %[drapeau][largeur].[précision]lettre.

printf("%5d|\n",    42);        /*     42|   largeur 5, cale a droite */
printf("%-5d|\n",   42);        /* 42    |   cale a gauche            */
printf("%05d\n",    42);        /* 00042     complete par des zeros    */
printf("%+d\n",     42);        /* +42       signe toujours affiche    */
printf("%.2f\n",    3.14159);   /* 3.14      deux decimales            */
printf("%8.3f|\n",  3.14159);   /*    3.142| largeur 8, trois decimales */
printf("%10.4f|\n", 2.0/3.0);   /*     0.6667|                          */

La largeur est un minimum : si le nombre est plus long, il n'est jamais tronqué. La précision, elle, arrondit réellement.

Ces réglages servent surtout à aligner des colonnes de chiffres, ce qui rend une sortie immédiatement plus lisible.

Les séquences d'échappement

Certains caractères ne peuvent pas s'écrire directement dans une chaîne. On les note avec une barre oblique inverse.

Oublier le \n final est sans gravité, mais les affichages se collent les uns aux autres sur la même ligne.

L'erreur la plus courante

double prix = 1500.75;
printf("%d\n", prix);    /* FAUX : %d attend un int, on lui donne un double */

Le programme compile, printf ne vérifie rien à l'exécution, et affiche une valeur absurde. Avec -Wall, gcc vous prévient : format '%d' expects argument of type 'int', but argument 2 has type 'double'.

À chaque marqueur doit correspondre un argument, du bon type, dans le bon ordre. printf ne s'en assure pas : c'est votre travail, et celui de -Wall.

9. Lire une saisie avec scanf

scanf est le miroir de printf : elle lit ce que l'utilisateur tape au clavier et le range dans vos variables.

int age;
printf("Quel est ton age ? ");
scanf("%d", &age);
printf("Tu as %d ans.\n", age);

Pourquoi cette esperluette

C'est la question que tout le monde pose, et la réponse éclaire une bonne partie du C.

printf a seulement besoin de lire votre variable : on lui passe sa valeur, et cela suffit.

scanf, lui, doit écrire dedans. Si on lui passait la valeur, il recevrait une copie, et modifier une copie ne changerait rien à l'original. Il lui faut donc savoir où se trouve la variable : son adresse en mémoire. C'est exactement ce que donne l'opérateur &, qui se lit « adresse de ».

Oublier le & est une erreur grave. scanf reçoit alors la valeur de la variable et la prend pour une adresse : il écrit dans une zone mémoire qui ne vous appartient pas. Le programme s'arrête brutalement, ou, bien pire, continue avec des données abîmées.

Les marqueurs de scanf

double x;
scanf("%lf", &x);     /* correct   */
printf("%f\n", x);      /* correct aussi */
scanf("%f", &x);      /* FAUX : scanf ecrira 4 octets dans une case de 8 */

Le retour chariot qui reste

Quand l'utilisateur tape 25 puis Entrée, scanf("%d") consomme les deux chiffres… et laisse le retour à la ligne dans la mémoire tampon du clavier.

Avec %d ou %f, ce n'est pas grave : ils sautent automatiquement les espaces et les retours à la ligne. Mais %c ne saute rien :

int age;
char initiale;

scanf("%d", &age);
scanf("%c", &initiale);   /* lit le retour a la ligne, pas la lettre ! */

La parade tient à un espace, glissé devant le %c :

scanf(" %c", &initiale);   /* l'espace avale les blancs en attente */

Vérifier que la saisie a réussi

scanf renvoie le nombre de valeurs correctement lues. On peut donc savoir si l'utilisateur a tapé n'importe quoi.

int age;
int lus = scanf("%d", &age);
printf("scanf a lu %d valeur(s)\n", lus);
/* 1 : une valeur lue. 0 : l'utilisateur n'a pas tape un nombre. */

Un programme sérieux teste cette valeur. Le traitement qui suit relève du cours sur les conditions ; retenez simplement dès maintenant que l'information existe et qu'on ne doit pas la jeter.

Lire plusieurs valeurs d'un coup

int jour, mois, annee;
printf("Date (jj mm aaaa) : ");
scanf("%d %d %d", &jour, &mois, &annee);

Un marqueur, une esperluette, dans l'ordre. L'utilisateur peut séparer ses nombres par des espaces, des tabulations ou des retours à la ligne : scanf ne fait pas la différence.

10. Les fonctions prédéfinies

Écrire ses propres fonctions fait l'objet d'un autre cours. En revanche, utiliser celles que l'on vous fournit fait partie des bases : c'est ce que vous faites depuis le début avec printf.

Une bibliothèque est un ensemble de fonctions déjà écrites, déjà testées et déjà compilées. Le fichier d'en-tête (.h) décrit comment les appeler ; le code, lui, est rattaché à votre programme par l'éditeur de liens.

Lire un prototype

La documentation d'une fonction se résume à une ligne, appelée prototype :

double sqrt(double x);
   ^      ^      ^
   |      |      +--- ce qu'elle attend : un double
   |      +---------- son nom
   +----------------- ce qu'elle renvoie : un double

Tout est là : le type de retour, le nom, les paramètres. Savoir lire un prototype, c'est savoir utiliser n'importe quelle bibliothèque.

<math.h> : les mathématiques

Toutes renvoient un double, même quand le résultat est un entier rond : ceil(3.2) vaut 4.0, pas 4. Affichez-les avec %f.

gcc calcul.c -o calcul -lm

Un exemple complet, l'hypoténuse d'un triangle rectangle :

#include <stdio.h>
#include <math.h>

int main(void)
{
    double a = 3.0, b = 4.0;
    double c = sqrt(a * a + b * b);
    printf("hypotenuse = %.2f\n", c);   /* affiche  hypotenuse = 5.00 */
    return 0;
}

<stdlib.h> : les outils généraux

Une remarque sur rand() : sans srand, la suite est la même à chaque exécution. C'est voulu : cela rend les essais reproductibles. Pour varier, on sème avec l'heure courante : srand(time(NULL));, qui demande #include <time.h>.

<stdio.h> : au-delà de printf

putchar('A');          /* affiche un seul caractere */
int c = getchar();     /* lit un seul caractere */

Ces deux-là sont plus simples et plus rapides que printf et scanf quand on ne manipule qu'un caractère.

Avant d'écrire une fonction, demandez-vous si elle n'existe pas déjà. Le code de la bibliothèque standard est écrit et relu depuis cinquante ans : le vôtre, non.

11. Les erreurs du débutant, et comment les reconnaître

Les messages du compilateur paraissent hostiles tant qu'on n'a pas compris qu'ils suivent presque toujours le même schéma : fichier:ligne:colonne, puis la nature du problème. Voici les dix qui reviennent le plus.

Les cinq réflexes qui font gagner du temps

1. Compilez souvent. Toutes les cinq ou dix lignes, pas à la fin. Une erreur dans dix lignes se trouve ; dans deux cents, elle se cherche.
2. Compilez avec -Wall -Wextra et traitez les avertissements comme des erreurs.
3. Indentez en écrivant, pas après coup.
4. Initialisez vos variables au moment où vous les déclarez.
5. Affichez les valeurs intermédiaires avec printf quand un résultat vous surprend. C'est le débogueur du pauvre, et il résout la moitié des cas.

Et maintenant ?

Vous savez fabriquer un programme, le structurer, déclarer des données, calculer, afficher et lire. C'est le socle : tout le reste s'appuie dessus.

La suite logique est de donner à votre programme la capacité de choisir (les structures conditionnelles) puis de répéter (les boucles). Viennent ensuite les tableaux, les fonctions et les pointeurs.

Mais d'abord, les trente exercices qui suivent. Faites-les au crayon avant d'ouvrir les corrigés : c'est en butant qu'on apprend.

Questions de cours

Quinze questions que l'on pose en examen, et qu'il faut savoir traiter en quelques phrases. Cherchez votre réponse avant d'ouvrir.

31 exercices corrigés

Six parties, qui suivent l'ordre du cours. Posez le calcul ou écrivez le programme sur une feuille avant d'ouvrir le corrigé : c'est en butant que l'on apprend.

#include <stdio.h>;

int Main(void)
{
    int age = 20
    printf("J'ai %d ans\n", age);
    return 0;

#include <stdio.h>

int main(void)
{
    int age = 20;
    printf("J'ai %d ans\n", age);
    return 0;
}

#include <stdio.h>

int main(void)
{
    printf("Groupe");
    printf(" Genius");
    printf("\n");
    printf("C\tbases\n");
    return 0;
}

Groupe Genius
C       bases

Awa Nkolo
Groupe Genius

#include <stdio.h>

int main(void)
{
    printf("Awa Nkolo\n");
    printf("Groupe Genius\n");
    return 0;
}

    printf("Awa Nkolo\nGroupe Genius\n");

#define CARRE(x) x * x

int resultat = CARRE(4);
int resultat = CARRE(2 + 2);

CARRE(2 + 2)   devient   2 + 2 * 2 + 2

#ifndef OUTILS_H
#define OUTILS_H

const double TAUX_TVA = 0.1925;

#endif

printf("%zu %zu %zu %zu %zu\n",
       sizeof(char), sizeof(short), sizeof(int),
       sizeof(float), sizeof(double));

int n = 2147483647;
printf("%d\n", n);
n = n + 1;
printf("%d\n", n);

2147483647
-2147483648

char c = 300;
printf("%d\n", c);

char d = 'A';
printf("%d %c\n", d, d);

44
65 A

prix_total    2eme_note    _temp     nbEleves
prix-total    moyenne       int       élèves
PRIX_MAX      note 1        Return    x2

const double TAUX = 0.1925;

int main(void)
{
    TAUX = 0.20;
    printf("%f\n", TAUX);
    return 0;
}

int main(void)
{
    int total;
    total = total + 100;
    printf("%d\n", total);
    return 0;
}

printf("%d\n", 7 / 2);
printf("%d\n", -7 / 2);
printf("%f\n", 7 / 2.0);
printf("%d\n", 1 / 3);
printf("%f\n", (double)7 / 2);

3
-3
3.500000
0
3.500000

int n = 4729;

int milliers = n / 1000;         /* 4 */
int centaines = (n / 100) % 10;  /* 7 */
int dizaines  = (n / 10) % 10;   /* 2 */
int unites    = n % 10;          /* 9 */

int somme = milliers + centaines + dizaines + unites;

int a = 12, b = 15, c = 17;
double moyenne = (a + b + c) / 3;
printf("%f\n", moyenne);

double moyenne = (double)(a + b + c) / 3;

int i = 5;
int a = i++;
printf("%d %d\n", a, i);

int j = 5;
int b = ++j;
printf("%d %d\n", b, j);

5 6
6 6

2 + 3 * 4
(2 + 3) * 4
10 % 3 * 2
10 - 4 - 3
20 / 4 / 5
7 + 3 % 4

printf("%d\n", 10 > 3);
printf("%d\n", 10 == 3);
printf("%d\n", 5 != 5);
printf("%d\n", !0);
printf("%d\n", (4 > 2) + (7 > 1));

1
0
0
1
2

printf("[%5d]\n", 42);
printf("[%-5d]\n", 42);
printf("[%05d]\n", 42);
printf("[%+d]\n", 42);
printf("[%.2f]\n", 3.14159);
printf("[%8.3f]\n", 3.14159);

[   42]
[42   ]
[00042]
[+42]
[3.14]
[   3.142]

Article          Prix
----------------------
Cahier        1250.00
Stylo          350.50
Calculatrice 12500.75

printf("%-12s %8s\n", "Article", "Prix");
printf("----------------------\n");
printf("%-12s %8.2f\n", "Cahier", 1250.00);
printf("%-12s %8.2f\n", "Stylo", 350.50);
printf("%-12s %8.2f\n", "Calculatrice", 12500.75);

Le dossier "C:\Genius" contient 100% des cours.

printf("Le dossier \"C:\\Genius\" contient 100%% des cours.\n");

double prix = 1500.75;
printf("%d\n", prix);

A vaut 65
a vaut 97
ecart = 32
'7' - '0' = 7

#include <stdio.h>

int main(void)
{
    char maj = 'A';
    char min = 'a';

    printf("%c vaut %d\n", maj, maj);
    printf("%c vaut %d\n", min, min);
    printf("ecart = %d\n", min - maj);
    printf("'7' - '0' = %d\n", '7' - '0');

    return 0;
}

int age;
printf("Ton age : ");
scanf("%d", age);
printf("%d ans\n", age);

int age;
char initiale;

printf("Age : ");
scanf("%d", &age);

printf("Initiale : ");
scanf("%c", &initiale);

printf("%d ans, initiale %c\n", age, initiale);

#include <stdio.h>

int main(void)
{
    int n;
    int lus;

    printf("Entrez un entier : ");
    lus = scanf("%d", &n);

    printf("scanf a lu %d valeur(s)\n", lus);

    return 0;
}

#include <stdio.h>
#include <math.h>

int main(void)
{
    double rayon;

    printf("Rayon du cercle : ");
    scanf("%lf", &rayon);

    printf("Perimetre : %.4f\n", 2 * M_PI * rayon);
    printf("Aire      : %.4f\n", M_PI * rayon * rayon);

    return 0;
}

#include <stdio.h>
#include <math.h>

int main(void)
{
    double a, b;

    printf("Premier cote  : ");
    scanf("%lf", &a);
    printf("Second cote   : ");
    scanf("%lf", &b);

    printf("Hypotenuse : %.2f\n", sqrt(a * a + b * b));

    return 0;
}

#include <stdio.h>

#define TAUX_TVA 0.1925

int main(void)
{
    double prix_ht;
    int quantite;

    printf("Prix unitaire HT (FCFA) : ");
    scanf("%lf", &prix_ht);
    printf("Quantite                : ");
    scanf("%d", &quantite);

    double total_ht = prix_ht * quantite;
    double tva      = total_ht * TAUX_TVA;
    double total_ttc = total_ht + tva;

    printf("\n%-16s %12.2f\n", "Total HT",  total_ht);
    printf("%-16s %12.2f\n",   "TVA 19,25%%", tva);
    printf("%-16s %12.2f\n",   "Total TTC", total_ttc);

    return 0;
}

Pour continuer

• Tous les tutoriels de langage C : la suite du parcours : structures de contrôle, boucles, et le reste.
• Exercices corrigés de langage C : une quarantaine de fiches, avec corrigés en accordéon.
• QCM de programmation C : pour vérifier ce qui est acquis.
• Codage des nombres en machine : pourquoi un float ne tombe pas juste, et ce que contient vraiment un int.
• Cours d'algorithmique : pour travailler le raisonnement indépendamment du langage.