Cours 1

Introduction à l'informatique

& programmation en C

Des premiers concepts jusqu'au code de la factorielle

Laurent Thiry — Programmation en C

« Le C, c'est comme un couteau suisse : efficace, polyvalent,
et vous pouvez vous couper si vous ne faites pas attention. »

1

🗺️ Plan du cours

Aujourd'hui, un étudiant a plus de puissance que la NASA en 1969. Vous l'utilisez pour regarder des vidéos de chats. C'est beau.
2

1. Qu'est-ce que l'informatique ?

Info = contraction d'information et d'automatique

Les 4 piliers

À retenir : L'informatique est la science. Le code est l'expression de cette science. Savoir coder sans comprendre l'algorithmique, c'est savoir écrire sans savoir quoi dire.
3

1.1 Petite chronologie éclair

AnnéeQuoiPourquoi c'est important
~250 av. J.-C.Algorithme d'Euclide (PGCD)Un des plus vieux algorithmes encore utilisés
1843Ada Lovelace — 1er programmeAvant même que la machine existe
1936Turing — machine de TuringFonde théoriquement l'informatique. A aussi cassé Enigma.
1945Von Neumann — architecture stockéeProgramme et données dans la même mémoire
1972Dennis Ritchie crée le CLe langage de UNIX, Linux, Windows… et votre factorielle
1980–90PC, Internet, WebL'informatique sort des labos.
Turing avait 24 ans en 1936. Vous aussi, vous avez 24 ans (ou presque). Où est votre machine de Turing ?
4

2. Représentation de l'information

Bits et octets

  • Bit : 0 ou 1 — unité élémentaire
  • Octet : 8 bits — 256 valeurs
  • Mot machine : 32 ou 64 bits
1 bit  → 2 valeurs
8 bits → 256 valeurs (0–255)
32 bits → 4 294 967 296
64 bits → 18 446 744 073 709 551 616

Binaire / Hexa

BinaireDécimalHexa
000000x0
010150x5
1010100xA
1111150xF
1 0000160x10
Les humains comptent en base 10 (10 doigts). Les ordis en base 2 (2 états). Les programmeurs en base 16 (parce que c'est plus court et qu'ils aiment se la jouer).
5

2.2 Entiers signés et limites

Complément à deux

Bit de poids fort = signe (1 = négatif). Plage long long (64 bits) :

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

20! = 2 432 902 008 176 640 000 tient encore.
21! dépasse — et le C ne vérifie pas.

🐛 Débordement silencieux (overflow) : le résultat devient faux sans avertissement. Le C ne vous tient pas la main.
Bon réflexe : demandez-vous toujours « est-ce que mes valeurs peuvent dépasser la plage du type ? »
✏️ Exercice : Calculez 20! et 21! avec factorielle.c. Observez le résultat de 21!. Conclusion ?
6

3. Algorithmique — l'art de résoudre

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

Propriétés

Exemple : faire un café

// Algorithme : préparer un café (version express)
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 la première étape est « prenez une vache » au lieu de « sortez le lait du frigo », le temps d'exécution explose. Et « salez à votre convenance » n'est pas un algorithme, c'est du wishful coding.
7

3.2 L'algorithme de la factorielle

n! = 1 × 2 × 3 × … × n (avec 0! = 1)

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;
}
Le pseudo-code a un avantage sur le C : personne ne vous dit « t'as oublié un point-virgule ». Inconvénient : ça ne compile pas.
8

4. Du problème au programme

📋 Problème
📐 Algorithme
📝 Pseudo-code
💻 Code C
  1. Comprendre le problème — entrées, sortie, cas particuliers
  2. Concevoir l'algorithme — méthode mathématique ou logique
  3. Écrire le pseudo-code — formaliser sans syntaxe
  4. Implémenter — traduire en C
  5. Tester — valider sur cas normaux, limites et d'erreur
🐛 Bug : une mite coincée dans un relais du Harvard Mark II en 1947. Grace Hopper a noté « First actual case of bug being found ».
9

5. Premiers pas en C

Le C, créé par Dennis Ritchie en 1972 chez Bell Labs. Il a écrit UNIX, qui a écrit Linux, qui fait tourner Internet.

Structure minimale

int main() {
    return 0;
}
  • { } délimitent un bloc
  • ; termine chaque instruction
  • return 0; = tout va bien

Avec affichage

#include <stdio.h>
int main() {
    printf("Bonjour les ingenieurs !\n");
    return 0;
}
  • #include insère un fichier d'en-tête
  • \n = saut à la ligne
printf est le couteau suisse de l'affichage. Il y a 50 façons de formater un nombre. Vous en utiliserez 4. Les 46 autres, vous les chercherez sur Internet — et c'est normal.
10

5.2 Variables et types

Une variable est une boîte qui contient une valeur. Le type dit quelle sorte de valeur va dedans.

TypeTailleExempleUsage
int32 bitsint n = 5;Entier signé
long long64 bitslong long x = 120LL;Très grand entier
float32 bitsfloat pi = 3.14f;Virgule simple précision
double64 bitsdouble pi = 3.14159;Virgule double précision
char8 bitschar c = 'A';Un caractère

Spécificateurs printf

%d → int · %lld → long long · %f → double · %c → char · %s → chaîne · %x → hexa

Convention : les constantes long long prennent un suffixe LL : 2432902008176640000LL.
11

6. Opérateurs et expressions

Arithmétique

OpOpérationExemple=
+Addition10+313
-Soustraction10-37
*Multiplication10*330
/Division entière10/33
%Modulo10%31

Comparaison & Logique

OpVrai si…
==égal à
!=différent de
< >plus petit/grand
&&ET (court-circuit)
||OU (court-circuit)
!NON
🚨 Piège : = (affectation) ≠ == (comparaison). if (n = 5) est toujours vrai. Activez -Wall.
&& et || sont paresseux : si la première partie suffit, la seconde n'est pas évaluée. C'est la flemme au niveau processeur.
12

7. Structures de contrôle

if / else

if (n < 0) {
    return -1;
} else {
    // calcul
}

for

for (int i = 2; i <= n; i++) {
    res *= i;
}

init ; condition ; incrément

while

int i = 2;
while (i <= n) {
    res *= i;
    i++;
}

Variantes for

// Parcourir un tableau
for (int i = 0; i < n; i++)
// Compter a rebours
for (int i = n; i > 0; i--)
// Pas de 2
for (int i = 0; i < 100; i += 2)
for = tour de manège (nombre de tours connu). while = attente du bus (on ne sait pas quand il arrive). Les deux font la même chose, mais le bon rend le code lisible.
13

8. Fonctions — son propre outillage

Fonction : boîte noire qui prend des paramètres et produit une valeur de retour.

Sans fonction

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

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;
}
La portée des variables, c'est comme les portes d'une maison : vous voyez votre salon, pas la chambre du voisin. Les variables globales, c'est entrer sans frapper — mal vu.
14

9. Construire factorielle

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;
}
EntréeDéroulementSortie
n = 0boucle non exécutée (2 ≤ 0 faux)1
n = 1boucle non exécutée (2 ≤ 1 faux)1
n = 51×2×3×4×5120
n = −3return -1 immédiat−1
Pourquoi commencer à 2 ? 1×n = n, multiplier par 1 est inutile. On économise un tour de boucle. C'est une micro-optimisation, mais aussi plus correct mathématiquement.
15

9.3 Variations sur factorielle

Récursive

long long fact_rec(int n) {
    if (n < 0) return -1;
    if (n <= 1) return 1;
    return n * fact_rec(n - 1);
}

Élégante, risque de pile pour n grand

Avec while

long long fact_while(int n) {
    if (n < 0) return -1;
    long long res = 1;
    int i = 2;
    while (i <= n) {
        res *= i; i++;
    }
    return res;
}

Décroissante

long long fact_desc(int n) {
    if (n < 0) return -1;
    long long res = 1;
    for (int i = n; i > 1; i--) res *= i;
    return res;
}
Laquelle est la meilleure ?
Itérative : O(n) temps, O(1) mémoire, pas de risque de pile. Le compilateur l'optimise très bien.
La récursion, c'est comme un meuble IKEA : vous répétez jusqu'à ce qu'il n'y ait plus de pièces. Élégant sur le papier, frustrant dans la pratique.
16

10. Tester son code

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

Type de testExemple
Cas nominalfactorielle(5) → 120
Cas limitefactorielle(0) → 1, factorielle(20) → 20!
Cas d'erreurfactorielle(-1) → -1
Dépassementfactorielle(21) → overflow silencieux
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]);
Un jour, votre programme aura un bug. La question n'est pas « est-ce qu'il y a un bug ? » mais « est-ce que le test va le trouver avant l'utilisateur ? ». Spoiler : l'utilisateur le trouve toujours.
17

11. La chaîne de compilation

📄 .c
🔧 Préprocesseur
⚙️ Compilateur
📝 Assembleur
🔗 Éditeur de liens
💾 Exécutable
ÉtapeFaitCommandeFichier
1. PréprocesseurRemplace #include, #definegcc -E
2. CompilationC → assembleurgcc -S.s
3. Assemblageassembleur → machinegcc -c.o
4. Édition de liens.o + biblio → exécutablegccfactorielle
La chaîne de compilation, c'est comme une usine à saucisses : du C frais d'un côté, des bibliothèques bio, et de l'autre côté un binaire prêt à consommer. Activez -Wall comme vous lavez les légumes.
18

Exercices — niveau ★☆☆

✏️ Ex. 1 — factorielle_boucle (★) : Réécrivez factorielle avec une boucle while au lieu de for. Vérifiez que les résultats sont identiques.
✏️ Ex. 2 — affichage (★) : Modifiez le main pour afficher un tableau joli : n | n! | OK/FAIL. Utilisez %10d et %20lld pour aligner.
✏️ Ex. 3 — somme_1_a_n (★) : Écrivez long long somme(int n) qui calcule 1+2+…+n avec une boucle. Comparez avec la formule n(n+1)/2.

Niveau ★★☆

✏️ Ex. 4 — combinatoire (★★) : Écrivez long long C(int n, int k) qui calcule C(n,k) = n! / (k! (n-k)!) en utilisant factorielle. Testez avec C(5,2) = 10. Évitez l'overflow en simplifiant avant de multiplier.
✏️ Ex. 5 — interactive (★★) : Modifiez le main pour lire n au clavier avec scanf. Bouclez jusqu'à ce que l'utilisateur entre une valeur négative. Ajoutez un message d'erreur si n > 20.

Niveau ★★★

✏️ Ex. 6 — big factorielle (★★★) : Écrivez une version qui calcule n! avec des grands nombres (tableau de chiffres, comme à la main). Gérez n arbitrairement grand. Affichez 100! (93 chiffres).
19

Vous avez survécu au cours 1 !

Vous savez ce qu'est un algorithme, un bit, une variable,
une boucle, une fonction, un compilateur —
et pourquoi votre café refroidit pendant que vous codez.

📄 Fichier clé
factorielle.c
📚 Prochain cours
Cours 2 — Machine Virtuelle
🛠️ Commandes
make && make run
Le monde de l'informatique s'ouvre à vous — n'oubliez pas le point-virgule.
« On n'arrête pas le progrès. Surtout quand il tient dans un Makefile. »
20