📘 Cours 1 — Introduction à l'informatique
& programmation en C

Informatique vient de la contraction d'information et d'automatique. Ce n'est pas l'étude des ordinateurs — c'est l'étude de la représentation, du traitement et de la transmission de l'information de manière automatique.

L'informatique n'est pas la science des ordis

Un ordinateur n'est qu'un outil. L'informatique, c'est :

• L'algorithmique : comment résoudre un problème par une suite d'étapes finies et non-ambiguës.
• La structure des données : comment organiser l'information pour la manipuler efficacement.
• Le génie logiciel : comment construire des programmes fiables, maintenables, et qui ne mettent pas le feu au datacenter.
• Les langages : comment exprimer des algorithmes dans un formalisme compréhensible par la machine… et par les humains.

Petite chronologie éclair

Bits, octets, nombres

Un ordinateur ne comprend que deux états : 0 et 1 — c'est le binaire. Chaque 0 ou 1 est un bit (Binary digit). 8 bits forment un octet (byte).

1 bit  → 2 valeurs :  0 ou 1
 8 bits → 256 valeurs : 0 à 255
32 bits → 4 294 967 296 valeurs
64 bits → 18 446 744 073 709 551 616 valeurs

Compter en binaire

On compte en base 2 (binaire) comme on compte en base 10 (décimal) :

En hexadécimal (base 16), on utilise 0–9 puis A–F pour représenter les valeurs 10 à 15. C'est très utilisé en programmation pour lire des octets : 0x7F est plus lisible que 01111111.

Entiers signés et limites

Pour représenter des nombres négatifs, on utilise le complément à deux : le bit de poids fort (le plus à gauche) indique le signe (1 = négatif).

Avec long long (64 bits signés), la plage est :

−9 223 372 036 854 775 808  à  +9 223 372 036 854 775 807

Notre 20! = 2 432 902 008 176 640 000 tient encore. 21! dépasse, et le C ne vérifie pas — c'est le débordement (overflow). Le résultat devient faux silencieusement.

Qu'est-ce qu'un algorithme ?

Algorithme : une suite finie d'instructions non-ambiguës qui, partant d'entrées données, produit une sortie et se termine en temps fini.

Un algorithme doit être :

• Fini — il s'arrête (pas de boucle infinie)
• Non-ambigu — chaque étape est claire
• Efficace — il utilise des ressources raisonnables (temps, mémoire)
• Général — il fonctionne pour toutes les entrées valides

Exemple du quotidien : faire un café

// Algorithme : préparer un café (version express)
Données : eau, café moulu, machine
Résultat : une tasse de café potable

1. Remplir le réservoir d'eau
2. Mettre le café dans le filtre
3. Placer la tasse sous la sortie
4. Allumer la machine
5. Attendre que la tasse soit pleine
6. Servir

Si l'une des étapes est ambiguë (« mettre un peu de café »), le résultat varie selon l'exécutant. En programmation, c'est pareil — la machine ne devine pas. Elle exécute exactement ce qui est écrit.

Exemple : la recette de la factorielle

Pour calculer n! (produit de 1 à n), on peut écrire :

Entrée : un entier n ≥ 0
Sortie : n! (le produit 1 × 2 × 3 × … × n)

         Si n = 0 → retourner 1
         Sinon :
           résultat = 1
           Pour i de 1 à n :
               résultat = résultat × i
           Retourner résultat

On initialise un accumulateur, on le multiplie par chaque entier, on rend le résultat. C'est une approche itérative — on répète une opération un nombre connu de fois.

Pseudo-code

Le pseudo-code est un langage informel pour décrire un algorithme sans se soucier de la syntaxe d'un vrai langage. On en trouve partout : dans les livres, sur les tableaux blancs, et dans les copies d'étudiants le matin de l'examen.

Pseudo-code
Fonction factorielle(n):
    Si n < 0 alors
        retourner -1
    Fin Si
    res ← 1
    Pour i ← 2 à n faire
        res ← res × i
    Fin Pour
    retourner res

C réel
long long factorielle(int n) {
    if (n < 0) return -1;
    long long res = 1;
    for (int i = 2; i <= n; i++) {
        res *= i;
    }
    return res;
}

Les grandes étapes pour transformer un problème en code qui marche :

1. Comprendre le problème : quelles sont les entrées ? la sortie attendue ? les cas particuliers ?
2. Concevoir l'algorithme : quelle méthode mathématique ou logique permet de résoudre le problème ?
3. Écrire le pseudo-code : formaliser sans se perdre dans la syntaxe.
4. Implémenter : traduire le pseudo-code dans un langage de programmation.
5. Tester : vérifier que le résultat est correct — sur des cas normaux, des cas limites, et des cas d'erreur.

Le C est un langage compilé, impératif, créé en 1972 par Dennis Ritchie chez Bell Labs. Il a écrit UNIX, qui a écrit Linux, qui fait tourner Internet et les téléphones Android. Bref : le C, c'est le socle.

Structure d'un programme

Tout programme C commence par main() :

int main() {
    return 0;
}

Syntaxe : ensemble des règles d'écriture du langage. Comme en français, chaque phrase a une structure. Ici :

• Les accolades { } délimitent un bloc
• Chaque instruction se termine par ;
• return 0; signifie « tout s'est bien passé »

Afficher du texte

Pour communiquer avec l'utilisateur, on utilise printf (déclarée dans <stdio.h>) :

#include <stdio.h>

int main() {
    printf("Bonjour les ingenieurs !\n");
    return 0;
}

Variables et types

Une variable est une boîte qui contient une valeur. Le type dit quelle sorte de valeur peut aller dans la boîte :

printf et les formats

printf utilise des spécificateurs de format pour afficher des variables :

printf("factorielle(%d) = %lld\n", n, res);
// Affiche : factorielle(5) = 120

Les opérateurs permettent de combiner des valeurs pour en produire de nouvelles.

Arithmétique

Attention : la division entre deux entiers donne un entier (troncature, pas d'arrondi). 10 / 3 = 3, pas 3,333…

int a = 10 / 3;     // a = 3 (division entière)
double b = 10.0 / 3; // b = 3.333333 (division réelle)

Les opérateurs abrégés : res *= i équivaut à res = res * i. Ça marche pour +=, -=, /=, %= aussi.

Comparaison

Logique

Pour combiner des conditions :

Un programme linéaire s'arrête vite. Pour faire des choix et répéter des actions, on a les structures de contrôle.

if / else — prendre une décision

Exécute un bloc si la condition est vraie, un autre sinon :

if (n < 0) {
    return -1;   // pas de factorielle pour les negatifs
} else {
    // continuer le calcul
}

Condition : toute expression qui vaut 0 (faux) ou ≠ 0 (vrai). En C, il n'y a pas de type booléen dédié avant C99 (stdbool.h apporte bool). Avant, on utilise int.

for — répéter un nombre connu de fois

La boucle for est parfaite quand on sait à l'avance combien de fois répéter :

// Structure : for (initialisation ; condition ; incrément)
for (int i = 2; i <= n; i++) {
    res *= i;
}

Les trois parties :

1. Initialisation : int i = 2 — exécutée une fois au début
2. Condition : i <= n — testée avant chaque tour ; si fausse, on sort
3. Incrément : i++ — exécuté à la fin de chaque tour

Variantes

// Parcourir un tableau d'éléments
for (int i = 0; i < nb_tests; i++) { ... }

// Compter à rebours
for (int i = n; i >= 1; i--) { ... }

// Pas de 2
for (int i = 0; i < 100; i += 2) { ... }

while — répéter tant qu'une condition est vraie

Quand on ne sait pas à l'avance combien de tours, on utilise while :

while (condition) {
    // corps
}

// Exemple : tant que l'utilisateur n'a pas donné une valeur valide
int n;
printf("Entrez n (0-20) : ");
scanf("%d", &n);
while (n < 0 || n > 20) {
    printf("Valeur invalide. Recommencez : ");
    scanf("%d", &n);
}

Notre factorielle utilise for car on connaît exactement le nombre d'itérations (n−1 multiplications).

Pourquoi découper ?

Une fonction est une boîte noire qui prend des paramètres en entrée et produit une valeur de retour. Avantages :

• Réutilisabilité : écrire une fois, utiliser partout
• Lisibilité : le code principal devient une suite d'appels de haut niveau
• Testabilité : on peut tester chaque fonction indépendamment
• Maintenabilité : corriger un bug dans la fonction le corrige partout

// Sans fonction : tout dans main
int main() {
    int n = 5;
    long long res = 1;
    for (int i = 2; i <= n; i++) res *= i;
    printf("%lld\n", res);
    return 0;
}

// Avec fonction : factorielle est réutilisable, testable
long long factorielle(int n) {
    long long res = 1;
    for (int i = 2; i <= n; i++) res *= i;
    return res;
}

int main() {
    printf("%lld\n", factorielle(5));
    return 0;
}

Syntaxe et vocabulaire

type_retour nom_de_la_fonction(type_param1 nom1, type_param2 nom2) {
    // corps
    return valeur;  // doit correspondre au type_retour
}

Portée des variables

Une variable déclarée à l'intérieur d'une fonction n'existe que dans cette fonction. On dit que sa portée (scope) est locale.

int factorielle(int n) {
    long long res = 1;   // locale : n'existe que ici
    for (int i = 2; i <= n; i++) {
        res *= i;         // i aussi est local à la boucle (C99)
    }
    return res;
} // res et n disparaissent ici

int main() {
    printf("%d", n);    // ERREUR : n n'existe pas ici
    return 0;
}

Version 1 : juste la fonction

Commençons par l'essentiel. On veut une fonction qui calcule n! :

long long factorielle(int n) {
    if (n < 0) return -1;     // protection : pas de factorielle négative
    long long res = 1;       // accumulateur : 0! = 1, on part de 1
    for (int i = 2; i <= n; i++) {  // on commence à 2 (×1 ne change rien)
        res *= i;            // accumulateur : res = res × i
    }
    return res;              // retour du résultat
}

Version 2 : avec tests

Une fonction, ça se teste. On ajoute un main() avec une batterie de cas :

int main() {
    struct {
        int n;
        long long attendu;
    } tests[] = {
        {0, 1},
        {1, 1},
        {2, 2},
        {3, 6},
        {5, 120},
        {10, 3628800},
        {12, 479001600},
        {20, 2432902008176640000LL},
    };
    int nb_tests = sizeof(tests) / sizeof(tests[0]);
    int passes = 0, echoues = 0;

    for (int i = 0; i < nb_tests; i++) {
        long long res = factorielle(tests[i].n);
        if (res == tests[i].attendu) {
            printf("OK   factorielle(%d) = %lld\n", tests[i].n, res);
            passes++;
        } else {
            printf("FAIL factorielle(%d) = %lld (attendu %lld)\n",
                   tests[i].n, res, tests[i].attendu);
            echoues++;
        }
    }

    printf("\n%d passes, %d echoues sur %d tests\n", passes, echoues, nb_tests);
    return echoues > 0 ? 1 : 0;
}

Quelques nouveautés dans ce code :

• Structure (struct) : permet de regrouper plusieurs valeurs de types différents dans une même entité. Ici, on couple n (l'entrée) et attendu (le résultat attendu).
• Tableau (tests[]) : une collection d'éléments de même type, indexée par un entier.
• sizeof(tests) / sizeof(tests[0]) : astuce pour calculer le nombre d'éléments d'un tableau à la compilation.
• Opérateur ternaire cond ? a : b : si cond est vraie, vaut a, sinon b. C'est un if/else compressé.

Variations

Voici d'autres façons d'écrire la même chose — chacune avec ses avantages et inconvénients :

// Version récursive (élégante, risquée pour n grand)
long long factorielle_rec(int n) {
    if (n < 0) return -1;
    if (n <= 1) return 1;
    return n * factorielle_rec(n - 1);
}

// Version avec while (équivalente, style différent)
long long factorielle_while(int n) {
    if (n < 0) return -1;
    long long res = 1;
    int i = 2;
    while (i <= n) {
        res *= i;
        i++;
    }
    return res;
}

// Version décroissante (moins efficace, mais instructive)
long long factorielle_desc(int n) {
    if (n < 0) return -1;
    long long res = 1;
    for (int i = n; i > 1; i--) {
        res *= i;
    }
    return res;
}

La version itérative (notre version) est la meilleure pour ce cas : O(n) en temps, O(1) en mémoire, pas de risque de débordement de pile, et le compilateur l'optimise très bien (elle est courte).

Un programme non testé est un programme qui a tort — mais qui ne le sait pas encore. Tester permet de :

• Vérifier que le code fait ce qu'on attend
• Détecter les régressions : quand une modification casse quelque chose qui marchait avant
• Documenter le comportement attendu par l'exemple

Quoi tester ?

Notre batterie de 8 tests couvre les cas nominaux (5, 10, 12) et les cas limites (0, 1, 20). Le cas d'erreur (n négatif) n'est pas testé automatiquement — on pourrait l'ajouter.

Comment passe-t-on du code C lisible… au binaire que le processeur exécute ? Voici les étapes, visibles avec notre Makefile :

En pratique avec notre Makefile

# 1. Générer l'assembleur (.s)
gcc -Wall -Wextra -std=c99 -S -o factorielle.s factorielle.c

# 2. Assembler le .s en exécutable
gcc -Wall -Wextra -std=c99 -o factorielle-asm factorielle.s

# 3. Tout d'un coup
gcc -Wall -Wextra -std=c99 -o factorielle factorielle.c

Le fichier factorielle.s est un fichier texte en assembleur (AT&T, le style par défaut chez GCC). Chaque ligne correspond à une instruction processeur : movq, addl, imulq, etc.

Ce cours pose les fondations. Les documents suivants approfondissent chaque aspect avec le même style et la même rigueur :

Quelques conseils pour la suite

• Expérimentez : modifiez factorielle.c, regardez comment l'assembleur change avec make asm. Comparez -O0 et -O2 avec make perf.
• Débuggez : make debug lance gdb avec un point d'arrêt. Utilisez next, step, print n pour suivre l'exécution pas à pas.
• Lisez l'assembleur : ouvrez factorielle.s (généré par make asm) et retrouvez la boucle. C'est comme une version « hardcore » de votre code.
• Testez des cas extrêmes : que donne factorielle(21) ? Pourquoi ? Comment détecter l'overflow ?