Le langage C reste incontournable dans les domaines du système, de l’embarqué et de la programmation haute performance. Cette formation de 5 jours, alignée sur la norme C17, vous donne une maîtrise solide des fondamentaux : types, structures de contrôle, fonctions, pointeurs, gestion mémoire dynamique et fichiers. Vous découvrez aussi la compilation séparée avec Makefile, l’outillage moderne avec valgrind, AddressSanitizer et gdb, et l’usage critique de l’IA pour produire et relire du code C.

Public visé

Développeurs.

Prérequis

Avoir suivi cette formation, ou en maîtriser les thèmes abordés :

Initiation à la programmation

Objectifs pédagogiques

À l’issue de cette formation, vous serez capable de :

Rédiger des programmes C structurés conformes à la norme C17
Organiser un projet C en compilation séparée
Exploiter les bibliothèques standard du C
Déclarer, définir et invoquer des fonctions à l’aide de prototypes
Maîtriser les pointeurs et la gestion mémoire dynamique
Manipuler les chaînes de caractères en évitant les débordements
Détecter les erreurs mémoire avec valgrind et les sanitizers ASan et UBSan
Utiliser un assistant IA pour produire, relire et tester du code C de façon critique

Programme

Jour 1

Mise en route et types

Environnement et chaîne de compilation

situer le langage parmi ses normes — choix de C17 par défaut
choisir un compilateur — GCC, Clang
distinguer les phases de compilation
compiler en mode strict — -std=c17, -Wall, -Wextra, -Wpedantic

Travaux pratiques :

Compiler un même programme sous GCC puis Clang en mode strict et comparer les diagnostics

Squelette d’un programme C

structurer un fichier source — main, paramètres argc/argv, code de retour
inclure les bibliothèques standard
comprendre le rôle de la fonction main comme point d’entrée

Travaux pratiques :

Écrire un programme qui affiche ses arguments et retourne un code de sortie significatif

Déclaration de variables

exploiter les types prédéfinis
choisir des types à largeur fixe — <stdint.h>
utiliser les booléens natifs — <stdbool.h>
définir des constantes — const, #define, énumérations
composer des types complexes — tableaux, structures, unions
créer des alias de types avec typedef

Travaux pratiques :

Inspecter les tailles des types avec sizeof et choisir des types adaptés à plusieurs cas tels qu’ID, compteur ou drapeau

Jour 2

Instructions et structures de contrôle

Opérateurs et expressions

combiner les opérateurs arithmétiques, logiques, relationnels et bit à bit
exploiter les formes abrégées
maîtriser les conversions et promotions de type
comprendre la précédence et l’associativité

Travaux pratiques :

Implémenter une calculatrice qui illustre conversions implicites et opérateurs bit à bit

Structures de contrôle

contrôler le flux avec if / else et l’opérateur ternaire
ramifier sur valeur avec switch / case
itérer avec les boucles while, do…while et for
maîtriser les sorties anticipées

Travaux pratiques :

Écrire un programme de jeu simple type devine le nombre, combinant boucles et branchements

Préprocesseur

définir des constantes et des macros avec #define
composer la compilation conditionnelle
protéger les en-têtes avec des include guards

Travaux pratiques :

Activer/désactiver un mode debug d’un programme via une macro de compilation

Jour 3

Fonctions et chaînes de caractères

Fonctions

distinguer définition et déclaration via le prototype
organiser le code en .h / .c avec include guards
choisir le passage par valeur ou par adresse selon le besoin
maîtriser portée et durée de vie — static, extern
protéger les paramètres en lecture seule avec const

Travaux pratiques :

Découper un programme monolithique en plusieurs fichiers avec prototypes et static

Chaînes de caractères

comprendre la représentation — tableau de char terminé par \0
manipuler les chaînes avec <string.h>
éviter les fonctions dangereuses — gets retirée en C11
convertir des chaînes en valeurs numériques

Travaux pratiques :

Implémenter une fonction de copie sûre comparée à strcpy sur des cas limites

Compilation séparée

organiser un projet en plusieurs fichiers source et leurs dépendances
automatiser la compilation avec un Makefile simple

Travaux pratiques :

Construire un Makefile minimal qui compile, lance les tests et nettoie

Jour 4

Pointeurs, mémoire et fichiers

Pointeurs

comprendre adresse et déréférencement
relier pointeurs, tableaux et chaînes
distinguer pointeur constant et pointeur vers const
exploiter les pointeurs sur fonctions pour les callbacks
repérer les risques — pointeur non initialisé, pendouillant, débordement

Travaux pratiques :

Implémenter un tri générique paramétré par une fonction de comparaison passée en pointeur

Allocation dynamique

allouer et libérer la mémoire dynamiquement
adopter les bonnes pratiques — tester le retour, libérer, passer à NULL après free
éviter les pièges des fuites mémoire, doubles libérations et use-after-free

Travaux pratiques :

Construire un tableau dynamique redimensionnable avec realloc

Outils de diagnostic

détecter les erreurs mémoire avec valgrind
activer les sanitizers — -fsanitize=address, -fsanitize=undefined
déboguer interactivement avec gdb

Travaux pratiques :

Faire passer un programme bogué sous valgrind puis ASan, corriger les défauts détectés

Fichiers

ouvrir et fermer un fichier avec fopen / fclose
lire et écrire en mode texte
lire et écrire en mode binaire — fread, fwrite
gérer les erreurs d’E/S — errno, perror

Travaux pratiques :

Sauvegarder et recharger un état de programme dans un fichier binaire

Jour 5

Structures dynamiques, qualité et IA

Structures de données dynamiques

implémenter une liste chaînée simple puis double
gérer les opérations de base d’ajout, suppression et parcours
libérer proprement toute la mémoire allouée

Travaux pratiques :

Implémenter une liste chaînée doublement liée avec ses primitives d’insertion et suppression

Modularité et bonnes pratiques

organiser un projet C en modules cohérents
adopter des conventions de nommage et de codage
pratiquer la programmation défensive avec assert
introduire des tests unitaires simples

Travaux pratiques :

Ajouter une suite de tests unitaires à un module de la liste chaînée

Qualité et sécurité du code

exploiter les warnings du compilateur en mode strict
compléter par l’analyse statique — cppcheck, clang-tidy
reconnaître les erreurs courantes de comportements indéfinis et de conversions implicites

Travaux pratiques :

Auditer un module existant avec cppcheck et corriger les avertissements remontés

C et IA

situer les assistants IA disponibles — GitHub Copilot, Claude, ChatGPT, modèles locaux
identifier les cas d’usage en C
repérer les pièges spécifiques — APIs hallucinées, fonctions dépréciées non détectées, comportements indéfinis ignorés
formuler des prompts efficaces
vérifier systématiquement — compilation stricte, valgrind, sanitizers, tests

Travaux pratiques :

Projet final : programme intégrant fichiers, structures dynamiques et Makefile, vérifié sous valgrind et soumis à une relecture assistée par IA

Modalités d’évaluation des acquis

En cours de formation, par des études de cas ou des travaux pratiques. En fin de formation, par un questionnaire d’auto-évaluation.

Pour aller plus loin

Cette formation donne accès aux formations suivantes :

Voir aussi

Vous serez peut-être intéressés par les formations suivantes :

Formation DEV-C-100 — C - Initiation. Domaine : Développement. Niveau : Initiation. Durée : 5 jours (35 heures). Cylian Formation, Dijon.