Le langage C

Python interprète : un programme lit votre texte et l'exécute au fil de la lecture. C compile : un programme lit votre texte en entier et fabrique un fichier exécutable, que la machine exécutera ensuite sans plus rien connaître de votre source.

bonjour.c   --[compilation]-->   bonjour.o   --[édition de liens]-->   bonjour
 (source)                         (objet)                            (exécutable)

En pratique, une seule commande enchaîne les deux étapes :

gcc -Wall -Wextra -std=c99 -o bonjour bonjour.c
./bonjour

C distingue les entiers signés et non signés, et fixe leur taille en bits. L'annexe retient :

Quand la taille exacte n'apporte rien, on écrit simplement int et unsigned int. Les opérations sont +, -, , /, et % entre opérandes positifs*.

• double : un flottant, que l'on considère sur 64 bits. Opérations +, -, *, /.
• char : exclusivement un caractère codé sur un octet. La notation '\0' désigne le caractère nul, qui jouera un rôle décisif pour les chaînes.
• bool : les constantes true et false, les opérateurs !, &&, ||.

&& et || n'évaluent leur second opérande que si c'est nécessaire : si le premier de && est faux, le résultat est faux, et l'on s'arrête là. Ce n'est pas une optimisation : c'est un outil.

if (i < n && t[i] == 0) { ... }   /* t[i] n'est lu que si i < n : l'ordre PROTÈGE */

Écrite dans l'autre sens, cette condition lirait une case hors du tableau. On y reviendra.

if (c) { instructionsSiVrai; }
if (c) { instructionsSiVrai; } else { instructionsSiFaux; }

while (c) { corps; }

for (int i = 0; i < n; i = i + 1) { corps; }

Le for de C n'est pas le for de Python : ce n'est pas un parcours d'objet, c'est un while qui a rangé son initialisation, sa condition d'arrêt et son incrément sur une même ligne. On peut définir la variable de boucle dans l'initialisation, et sa portée est alors limitée à la boucle. break sort de la boucle la plus proche.

Une fonction se déclare (on annonce sa signature) et se définit (on donne son corps) :

int maximum(int a, int b);          /* déclaration : la signature seule */

int maximum(int a, int b) {         /* définition */
    if (a > b) { return a; }
    return b;
}

Le nombre de paramètres est toujours fixé — les fonctions à nombre variable d'arguments sont hors programme.

type T[s] déclare un tableau de s cases, où s est une constante littérale entière. On lit et écrit la case d'indice i par T[i], les indices allant de $0$ à $s-1$.

int t[5];                    /* 5 cases, contenu INDÉTERMINÉ */
int u[5] = {3, 1, 4, 1, 5};  /* initialisateur (utilisable après rappel) */
int m[3][4];                 /* tableau à deux dimensions : 3 lignes, 4 colonnes */

En C, il n'existe pas de type « chaîne ». Une chaîne est un char[] dont la fin est marquée par le caractère '\0'.

char mot[6] = "chien";   /* 5 lettres + le '\0' final : SIX cases, pas cinq */

Trois fonctions sont au programme : strlen (la longueur, sans compter la sentinelle), strcpy (la copie), strcat (la concaténation).

Une structure regroupe plusieurs champs sous un même nom.

struct point_s {
    double x;
    double y;
};
typedef struct point_s point;

point p;
p.x = 1.5;         /* accès à un champ d'une valeur */
point* q = &p;
q->y = -2.0;       /* accès à un champ à travers un pointeur : la flèche */

q->y est exactement (*q).y, en plus lisible. L'organisation en mémoire des structures n'est pas à connaître.

Un pointeur est une variable qui contient l'adresse d'une autre. On considère les pointeurs sur 64 bits.

int v = 42;
int* p = &v;     /* p contient l'ADRESSE de v      : & se lit « adresse de » */
int w = *p;      /* w reçoit la VALEUR pointée : 42 : * se lit « valeur en » */
*p = 7;          /* v vaut maintenant 7 : on a écrit À TRAVERS le pointeur */

NULL est le pointeur qui ne pointe sur rien. Déréférencer NULL — écrire p quand p vaut NULL — arrête brutalement le programme : c'est la violation de segment (segmentation fault*). C'est, paradoxalement, le bon cas : le système vous a arrêté au lieu de vous laisser corrompre des données.

Un tableau statique a une taille connue à l'écriture du programme. Quand la taille n'est connue qu'à l'exécution, on demande la mémoire au tas :

#include <stdlib.h>

/* Renvoie un tableau de n entiers, tous nuls, ou NULL en cas d'échec.
   L'appelant devra le libérer par free. Précondition : n >= 1. */
int* tableau_neuf(int n) {
    assert(n >= 1);
    int* t = malloc(n * sizeof(int));
    if (t == NULL) { return NULL; }      /* malloc peut ÉCHOUER */
    for (int i = 0; i < n; i = i + 1) { t[i] = 0; }
    return t;
}

/* ... plus tard ... */
int* t = tableau_neuf(1000);
/* usage */
free(t);          /* on REND la mémoire : sans cela, elle est perdue */

sizeof(int) donne la taille d'un int en octets ; malloc rend un void* que l'on transtype implicitement vers le bon type de pointeur.

Une structure ne peut pas se contenir elle-même : sa taille serait infinie. Elle peut en revanche contenir un pointeur vers une structure de même type — un pointeur, lui, a toujours la même taille. C'est ainsi que naissent les listes chaînées, les arbres, les graphes.

struct maillon_s {
    int valeur;
    struct maillon_s* suivant;   /* un POINTEUR vers un maillon : autorisé */
};
typedef struct maillon_s maillon;

La chaîne s'arrête là où suivant vaut NULL. On construira ces structures au chapitre chap:sequentielles.

int n = 42;
double x = 1.5;
printf("n vaut %d et x vaut %f\n", n, x);
scanf("%d", &n);      /* noter le & : scanf a besoin de l'ADRESSE pour écrire */

L'annexe précise que « la syntaxe des chaînes de format n'est pas exigible » : on n'apprend pas la liste des %. Les trois flux standard sont en revanche au programme : stdin (entrée), stdout (sortie), stderr (erreurs).