Objectifs du cours
Dans beaucoup d’équipes, le C reste la colonne vertébrale de briques critiques : systèmes embarqués, drivers, middleware, traitements haute performance. Cette formation remet des bases solides et communes pour écrire du C sûr, lisible et maintenable, afin de réduire les bugs coûteux en production et la dette technique. Vos développeurs apprennent à structurer un projet (.c/.h, build), raisonner précisément sur la mémoire et les pointeurs, manipuler la librairie standard, et fiabiliser les E/S fichiers. Nous posons des pratiques de qualité adaptées à l’entreprise : conventions, gestion d’erreurs, tests simples, revue de code. Les exercices ciblent des cas réels (parsing, structures de données, sérialisation) pour transférer rapidement dans vos applications. Résultat : un code C plus robuste, mesurable et prêt pour l’industrialisation (intégration continue, audits).
À l’issue de la formation, les participantes seront capables de :
- Construire des programmes C structurés (fichiers .c/.h, prototypes, organisation du code).
- Maîtriser la syntaxe et les instructions (opérateurs, contrôles de flux, tableaux).
- Déclarer, définir et appeler des fonctions ; raisonner sur la portée et l’édition de liens.
- Manipuler chaînes de caractères et bibliothèque standard (stdio.h, string.h, stdlib.h, …).
- Comprendre et utiliser les pointeurs (mémoire, tableaux, pointeurs de fonctions).
- Gérer les fichiers (texte/binaire) et erreurs d’E/S de manière sûre.
- Concevoir et utiliser des structures de données dynamiques simples (listes chaînées).
- Adopter de bonnes pratiques de compilation, débogage et qualité (warnings, gdb, organisation).
Public
-
Développeurs, ingénieurs (logiciel/systèmes/embarqué), testeurs, étudiants ou profils techniques démarrant en C.
Prérequis
-
Développeurs, ingénieurs (logiciel/systèmes/embarqué), testeurs, étudiants ou profils techniques démarrant en C.
Contenu du cours
Jour 1 — Environnement, cycle de build et bases du langage
-
Outils & projet
- Toolchain : gcc/clang, options clés (-Wall -Wextra -Werror -g), rôle de l’éditeur/IDE.
- Organisation : arborescence src/ & include/, entêtes, garde d’inclusion, Makefile (aperçu) ou CMake (aperçu).
-
Structure d’un programme C
- main, prototypes, #include, #define, constantes (const), préprocesseur (macro simple).
- Standards (C17/C23) : notions générales et portabilité.
-
Types & variables
- Types fondamentaux (int, char, float/double, bool), tailles et limites, conversions.
- Portée & durée de vie : auto, static, initialisation, règles de nommage.
-
E/S console
- printf/scanf, formats, pièges courants (espaces, tampons), setbuf/buffering.
-
Atelier (pertinent)
- Installer la toolchain, compiler un premier programme, analyser les warnings, paramétrer un exécutable avec arguments.
Jour 2 — Opérateurs, contrôles de flux, tableaux & chaînes
-
Expressions & opérateurs
- Arithmétiques, logiques, comparaison, bit à bit ; précédence/associativité ; incrément/décrément.
-
Contrôles de flux
- if/else, switch, for, while, do … while, break/continue ; menus pilotés par switch.
-
Tableaux & chaînes
- Tableaux statiques : déclaration, initialisation, parcours ; arithmétique de base sur indices.
- Chaînes : char[], terminator '\0', fonctions clés de string.h (strlen, strcpy/strncpy, strcat/strncat, strcmp/strncmp), précautions.
-
Atelier (pertinent)
- Écrire un mini-outil de statistiques (lecture au clavier, tableau de valeurs, min/max/moyenne), puis un parseur de ligne CSV simple.
Jour 3 — Fonctions, modularisation et pointeurs (fondamentaux)
-
Fonctions
- Déclaration vs définition, paramètres/retour, surcharges inexistantes, inline (notion), static interne.
- En-têtes réutilisables : prototypes, documentation minimale.
-
Pointeurs (base)
- Adresse & contenu (&, *), pointeurs et tableaux, pointeurs const, pièges (dangling, double free).
- Passage “par référence” via pointeur (modifier une variable depuis une fonction).
-
Mémoire dynamique
- malloc/calloc/realloc/free, vérification NULL, gestion de la capacité, règles d’ownership.
-
Atelier (pertinent)
- Écrire des fonctions de manipulation de chaînes “sûres” (longueur, copie limitée, concat), puis un petit vector dynamique (push/pop, redimensionnement).
Jour 4 — Fichiers, structures, énumérations et pointeurs avancés
-
Fichiers & E/S
- FILE*, fopen/fclose, fgets/fputs, fread/fwrite, fprintf/fscanf, mode texte vs binaire, errno/perror.
-
Types composés
- struct (compositions), enum (états/erreurs), typedef, unions (aperçu), bitfields (optionnel).
- Sérialisation simple : écrire/lire une struct (format texte puis binaire).
-
Pointeurs de fonctions
- Syntaxe, cas d’usage (callbacks), usage avec qsort et bsearch.
-
Atelier (pertinent)
- Construire un gestionnaire de “contacts” : saisie, stockage sur disque (texte + binaire), tri avec qsort (comparateur dédié).
Jour 5 — Listes chaînées, qualité du code et projet final
-
Structures dynamiques
- Listes chaînées simples & doubles : nœud, insertion (tête/queue/triée), suppression, parcours, complexité.
- Alternatives : pile/queue (selon rythme).
-
Qualité & débogage
- Tests rapides (assert), journalisation minimaliste, style & commentaires, documentation (doxygen, aperçu).
- Débogage gdb : breakpoints, pas à pas, inspection, backtrace ; contrôle mémoire (Valgrind si disponible).
-
Projet fil rouge
- Application console cohérente combinant : entrées utilisateur, structures (struct), pointeurs & mémoire dynamique, fichiers, tri/recherche, documentation et Makefile.
-
Clôture
- Revue de code guidée, pistes de progression (modules, tests unitaires, threads/pthreads, sockets).