Quand je prépare des candidats pour un poste en développement embarqué, la partie « test de codage en C/C++ » revient systématiquement. J’ai vu des élèves très bons sur le papier se crisper sur des exercices mal préparés — et d’autres, moins diplômés, briller parce qu’ils avaient une méthode. Ici je vous partage ce que je propose comme entraînement : 7 exercices ciblés et des méthodes de correction concrètes que j’utilise pour évaluer le fond et la forme du code embarqué.
Pourquoi ces exercices ?
Le développement embarqué demande des compétences spécifiques : maîtrise du langage C (et parfois C++ moderne limité), gestion fine de la mémoire, sens des contraintes temps réel et hardware, et souci du comportement dans des conditions limites. Je choisis des exercices courts mais riches en pièges pratiques — ils permettent d’évaluer à la fois la logique algorithmique, la qualité du code et la capacité à anticiper les problèmes matériels.
Comment lire cet article
Pour chaque exercice vous trouverez :
- La consigne
- Les contraintes importantes (taille mémoire, complexité, interblocage, ISR, etc.)
- Les points de vigilance et les pièges à éviter
- Une méthode de correction / grille d’évaluation que j’utilise
Exercice 1 — Manipulation de bits : masque et champs
Consigne : écrire une fonction qui lit/modifie un champ de bits (de largeur variable) à l’intérieur d’un registre 32 bits. La fonction doit accepter position et largeur et retourner la valeur extraite ou écrire une nouvelle valeur.
Contraintes : éviter tout décalage indéfini, prendre en compte width==32, protéger la valeur écrite (ne pas déborder le champ).
Points de vigilance : behaviour sur width==0 ou width>32, cast vers uint32_t, utilisation de masques calculés de manière sûre (1u << width provoque UB si width==32).
Méthode de correction :
- Correctness : 50 % — extrait/écrit correctement pour toutes les valeurs valides
- Robustesse : 20 % — gère width==0/32, protège les entrées
- Clarté : 15 % — noms explicites, commentaires succincts
- Sécurité : 15 % — pas d’UB, utilisation de types uint32_t
Exercice 2 — Liste chaînée en mémoire limitée
Consigne : implémenter une simple liste chaînée statique (pools d’objets) sans malloc. Fonctions : init_pool, alloc_node, free_node, find_by_id.
Contraintes : pas d’allocation dynamique, O(1) pour alloc/free si possible.
Points de vigilance : fragmentation, réutilisation correcte des noeuds, gestion concurrente si appel depuis ISR.
Méthode de correction :
- Fonctionnalité : 40 % — opérations d’alloc/free correctes
- Efficacité : 20 % — pas de parcours complet si pool libre géré en pile
- Sûreté : 20 % — protection contre double-free, index hors plage
- Documentation & tests : 20 % — cas de test fournis (recherche, saturation)
Exercice 3 — Buffer circulaire (ring buffer) pour ISR
Consigne : écrire un ring buffer simple pour producer-consumer où l’écriture peut se faire depuis une ISR et la lecture depuis la tâche principale. Implémenter push/pop non-bloquants.
Contraintes : éviter les verrous lourds, minimiser sections critiques, garantir cohérence sans malloc.
Points de vigilance : variables partagées correctement qualifiées volatile, barrières mémoire si nécessaire, conditions de débordement et d’underflow.
Méthode de correction :
- Sûreté temps réel : 40 % — push depuis ISR sûr, pas d’appel à des fonctions non-ISR
- Correctness : 30 % — pas de perte/duplication de données dans scénarios concurrents simples
- Clarté : 15 % — explication des choix (volatile, disable/enable IRQ)
- Tests : 15 % — tests unitaires simulant ISR / tâche
Exercice 4 — Détection de débordement de tableau
Consigne : écrire une fonction qui copie des données dans un buffer donné et renvoie une erreur si la source ne rentre pas. Montrer comment on éviterait les dépassements en production (assertions, canaries, tailles connues).
Contraintes : API compatible C, pas d’usage de strncpy considéré comme « magique » sans vérification.
Points de vigilance : off-by-one, ritorno codes, compatibilité avec chaînes terminées par '\0'.
Méthode de correction :
- Sécurité : 50 % — renvoie d’erreur clair, pas de overflow possible
- Ergonomie API : 20 % — retour d’erreur et documentation
- Test coverage : 30 % — tests limites, chaîne vide, pleine
Exercice 5 — Arithmétique en virgule fixe (fixed-point)
Consigne : implémenter une fonction de multiplication pour nombres en Q15 (int16_t représentant [-1,1) ) en conservant l’échelle correcte et en évitant l’overflow.
Contraintes : travailler en entiers, O(1), éviter float si CPU sans FPU.
Points de vigilance : promotion des types avant multiplication, correct rounding, saturation si nécessaire pour sécurité.
Méthode de correction :
- Exactitude : 40 % — résultats conformes aux tests (valeurs extrêmes incluses)
- Robustesse : 30 % — saturation et absence d’overflow
- Documentation & tests : 30 % — cas limites et justification du choix de rounding
Exercice 6 — Traitement d’événements et gestion d’état
Consigne : écrire un petit state machine (par enum) qui gère une séquence d’événements (start, stop, error, timeout) et produit actions correspondantes. Tester transition illégales.
Contraintes : code lisible, tests unitaires montrant transitions, éviter switch trop long sans commentaires.
Points de vigilance : état initial, re-entrance, reset après erreur.
Méthode de correction :
- Comportement : 50 % — transitions correctes, couverture des états
- Structure : 25 % — modularité, pas de spaghetti
- Tests : 25 % — scénarios normaux et fautifs
Exercice 7 — Diagnostic mémoire simple (détection de fuite)
Consigne : proposer une petite API de debug pour suivre allocations/frees (compteur, somme des tailles, plus quelques identifiants) afin de détecter fuites dans un système de test.
Contraintes : overhead minimal, possibilité de compiler out en production via macro (DEBUG_MEM).
Points de vigilance : thread-safety, impact sur timing, reporting clair.
Méthode de correction :
- Utilité : 40 % — informations suffisantes pour localiser fuites
- Impact : 30 % — possibilité de désactiver sans changer le code applicatif
- Documentation : 30 % — usage expliqué et exemples de sortie
Conseils généraux pour préparer ces exercices
Je demande souvent aux candidats d’écrire un petit jeu de tests unitaires (même basiques). Un code qui compile mais n’a pas de tests ou d’explications perd des points parce qu’il ne montre pas la pensée derrière les choix.
- Petits tests : montrez 5 cas minimum (nominal, limites hautes/basses, erreur, cas aléatoire).
- Commentaires courts mais utiles : expliquer pourquoi vous utilisez volatile, pourquoi vous évitez malloc, ou pourquoi vous appliquez une saturation.
- Style et const correctness : des prototypes clairs, const pour paramètres immuables, typedefs lisibles.
- Analyse de complexité et ressources : en embarqué c’est important — indiquez si votre solution est O(1) en mémoire, O(n) en temps, etc.
- Tests automatiques : si vous connaissez CMocka, Unity ou Google Test (pour C++), mentionnez l’usage ; sinon un petit main avec assertions suffit.
- Outils : static analyzers (Cppcheck, clang-tidy), valgrind (sur code non-embarqué) ou ASan quand possible — parlez-en dans vos commentaires si vous ne pouvez pas les lancer.
Barème type que j’applique
Pour que vous sachiez à quoi vous attendre, voici une grille rapide que j’utilise :
| Correctness | 40–50 % |
| Robustesse & sécurité | 20–30 % |
| Tests & documentation | 10–20 % |
| Performance & contraintes embarquées | 10–20 % |
Si vous vous entraînez, essayez de chronométrer vos sessions (entre 45 et 90 minutes par exercice), commentez chaque choix et fournissez 3 à 5 tests unitaires. Si vous voulez, envoyez-moi un de vos exercices et je peux le relire et vous donner un retour concret.