Le C est un langage de programmation vraiment facile à apprendre. Des variables, des fonctions, des instructions de contrôle du flux, des structures, des pointeurs, et c’est à peu près tout. Mais surtout, le C vous donne le contrôle : lorsque vous écrivez votre code en C, vous êtes le dieu.
Cependant, un grand pouvoir implique de grandes responsabilités. Vous pouvez faire fonctionner parfaitement et efficacement tout ce que vous souhaitez, mais vous pouvez aussi tout gâcher en introduisant dans votre programme des débordements de pile, des pointeurs pendants, des utilisations après libération, des déréférencements de pointeurs nuls, des doubles libérations, des fuites de mémoire, des accès mémoire hors limites, etc.
De plus, le C est un langage puissant qui vous donne le contrôle. Cela signifie toutefois qu’il offre beaucoup moins d’abstraction que le C++, Python et d’autres langages, et qu’il vous revient d’implémenter une grande partie de la logique nécessaire pour accomplir vos tâches. Par conséquent, il existe un écart considérable entre connaître la syntaxe du C et devenir un véritable programmeur C.
J’ai appris le C en 2024/2025, mais, sans mettre mes connaissances en pratique en écrivant de véritables programmes prêts à être utilisés en production, je suis passé à l’apprentissage du C++. J’ai ensuite commencé à développer des applications en C++ et avec Qt, ce que j’ai trouvé assez confortable. Cependant, ces derniers jours, je me suis heurté à des obstacles en essayant de développer une application compagnon pour CanoKey avec libcanokey. Son objectif initial était de me permettre de pratiquer la programmation avec C++ + Qt + Kirigami, mais je me suis rendu compte qu’il me reste encore beaucoup à apprendre pour passer de la « connaissance du C » à la « maîtrise du développement de programmes utiles en C ».
Cet article présente quelques exemples simples. J’espère qu’il aidera d’autres personnes qui viennent d’apprendre la syntaxe du C, mais ne savent pas encore comment écrire des programmes utiles dans ce langage.
La programmation orientée objet en C
Le C ne prend pas nativement en charge la POO. L’un de ses principaux types agrégés intégrés permettant de regrouper des valeurs s’appelle une structure. Celle-ci rassemble plusieurs membres de types intégrés au C ou d’autres types de structures au sein d’un même type, avec éventuellement du remplissage entre les membres. Cependant, de nombreux projets et bibliothèques de la communauté du logiciel libre écrits en C utilisent une conception pseudo-orientée objet mise en œuvre manuellement. Ils ne modifient pas la syntaxe du C ; ils utilisent simplement des structures pour obtenir le résultat souhaité.
L’idée de base
Définissez une structure :
typedef struct Counter
{
int a;
} Counter;
Et définissez quelques fonctions :
Counter *counter_create()
{
Counter *ans = malloc(sizeof *ans);
if (! ans) return NULL;
ans->a = 0;
return ans;
}
void counter_increase(Counter *self)
{
self->a++;
}
int counter_get_value(Counter *self)
{
return self->a;
}
Félicitations ! Vous avez implémenté une classe et ses méthodes en C.
Une classe C++ qui ferait la même chose ressemblerait à ceci :
class Counter
{
public:
Counter()
: a(0) {}
void increase()
{
this->a++;
}
int get_value() const
{
return this->a;
}
private:
int a;
}
L’idée fondamentale consiste à utiliser les structures comme des objets et les fonctions comme des méthodes.
Encapsulation
Nous considérons généralement les structures que nous définissons comme des objets et les manipulons à l’aide d’un ensemble de fonctions. Cependant, il reste possible de modifier directement les membres de ces structures, ce qui peut produire des comportements inattendus.
Le C ne fournit aucun mécanisme permettant d’empêcher la modification directe d’une structure tout en autorisant sa modification au moyen d’un ensemble donné de fonctions. Il existe toutefois une astuce qui peut nous aider à atteindre cet objectif.
Placez les déclarations de notre structure et de nos fonctions dans un fichier d’en-tête, counter.h :
#ifndef COUNTER_H
#define COUNTER_H
typedef struct Counter Counter;
Counter *counter_create();
void counter_increase(Counter *self);
int counter_get_value(Counter *self);
#endif
Et placez les implémentations dans counter.c :
#include "counter.h"
struct Counter
{
int a;
};
Counter *counter_create()
{
Counter *ans = malloc(sizeof *ans);
if (! ans) return NULL;
ans->a = 0;
return ans;
}
void counter_increase(Counter *self)
{
self->a++;
}
int counter_get_value(Counter *self)
{
return self->a;
}
Dans tout fichier source qui doit utiliser Counter, il suffit d’écrire :
#include "counter.h"
Votre fichier source sait désormais qu’il existe une structure appelée Counter et que certaines fonctions permettent de la manipuler. Cependant, il ne connaît ni les membres que contient cette structure ni le fonctionnement de ces fonctions. Il ne peut donc pas modifier directement la structure, à moins de convertir de force le pointeur vers un type connu.
Héritage
Définissez une autre structure :
typedef struct CounterPlusPlus
{
Counter pref;
int step;
} CounterPlusPlus;
Et définissez une méthode :
void counter_plus_plus_increase(CounterPlusPlus *self)
{
self->pref.a += self->step;
}
Nous pourrions certainement définir une fonction telle que int counter_plus_plus_get_value(CounterPlusPlus *self) pour récupérer la valeur de notre compteur amélioré. Mais ce n’est pas nécessaire !
Dans une structure, les membres sont disposés dans l’ordre de leur déclaration, même si du remplissage peut être inséré entre eux. Un CounterPlusPlus se compose d’un Counter suivi d’un int. Par conséquent, l’adresse d’une instance de CounterPlusPlus est identique à celle de son premier membre, pref !
Nous pouvons donc convertir CounterPlusPlus * en Counter *, le transmettre à int counter_get_value(Counter *self) et laisser la fonction le traiter comme un Counter. Cela fonctionnera exactement comme prévu !
Il s’agit d’une approche courante pour implémenter l’héritage en C. GObject utilise cette approche de manière très intensive, et nombre de ses types de données héritent ainsi de GObject.
Gestion des ressources et propriété
Le C nous donne la liberté d’allouer et de libérer de la mémoire, mais si nous n’utilisons pas cette liberté avec discernement, nous risquons fort de rencontrer des problèmes tels que des fuites de mémoire, des doubles libérations, des utilisations après libération, etc.
La propriété des ressources est une convention que suivent les programmeurs C pour les aider à gérer correctement la mémoire allouée. Vous trouverez davantage d’informations à ce sujet dans mon précédent article.
Communiquer directement avec le matériel
Vous savez peut-être que la programmation système fait largement appel au C et que ce langage peut communiquer directement avec le matériel. De nombreux débutants et programmeurs de niveau intermédiaire qui apprennent le C peuvent penser que cela repose sur des syntaxes particulières du C introduites par l’interface matérielle. Pourtant, ce n’est généralement pas le cas.
La plupart des fabricants fournissent une couche d’abstraction matérielle (HAL) pour leurs équipements afin de faciliter le développement de micrologiciels et de pilotes. Cette couche fournit des fonctions permettant de commander le matériel. Cependant, dans la plupart des cas, la HAL elle-même est également écrite en C. Alors, quelles constructions du C une HAL utilise-t-elle pour commander le matériel ?
En effet, certaines plateformes matérielles fournissent des instructions machine spéciales pour certaines opérations. Il est possible d’y accéder en intégrant du langage assembleur au C. Toutefois, dans la plupart des cas, communiquer avec le matériel en C ne demande rien de plus compliqué que d’écrire quelque chose comme ceci :
*((volatile uint32_t *)0x40000000UL) = 1;
Oui. Vous avez bien lu, et je ne plaisante pas. Une adresse, une conversion de type et une simple affectation d’un entier. C’est tout.
La plupart des matériels disposent de registres de commande permettant de contrôler leur fonctionnement. Il suffit d’y stocker des valeurs pour leur faire effectuer différentes tâches. Des techniques telles que le MMIO permettent de mapper ces registres dans un ou plusieurs espaces d’adressage, afin d’y accéder de manière très similaire à celle utilisée pour la mémoire ordinaire. En lisant les registres des périphériques et en y écrivant, nous pouvons configurer le matériel, contrôler son état de fonctionnement et déclencher les opérations prises en charge. La logique interne du périphérique interprète ces accès aux registres et effectue les actions correspondantes. Il existe d’autres techniques, telles que le PMIO, qui utilise un espace d’adressage d’E/S distinct sur les architectures qui le prennent en charge.
Rien de magique ni d’opaque.
Suggestions complémentaires
Les points énumérés ci-dessus ne représentent que la partie émergée de l’iceberg.
En ce moment, j’utilise le mode Étude proposé par un fournisseur de services basés sur un grand modèle de langage pour approfondir ces sujets. Il a généré une feuille de route, dont voici quelques points essentiels. J’espère qu’ils vous seront utiles.
- Gestion de la mémoire et propriété des ressources
- Allocation sur la pile et allocation sur le tas.
- Durée de vie des objets et durée de stockage.
- Propriété, emprunt et transfert de propriété.
- Copies superficielles et copies profondes.
- Comptage de références.
- Acquisition et libération des ressources.
- Initialisation partielle et nettoyage en cas d’échec.
- Prévention des fuites de mémoire, des doubles libérations et des utilisations après libération.
- Membres de tableaux flexibles.
- Alignement et remplissage.
- Débordement de la taille d’allocation.
- Conception d’API et encapsulation
- Structures opaques.
- Fichiers d’en-tête publics et fichiers d’en-tête privés.
- Constructeurs et destructeurs.
- Fonctions d’initialisation et de finalisation.
- Accesseurs et mutateurs.
- API de comptage de références.
- Copie et clonage.
- Contrats des fonctions.
- Préconditions et postconditions.
- Signalement des erreurs.
- Documentation des API.
- Conventions d’espaces de noms.
- API de rappel.
- Processus complet de compilation
- Prétraitement.
- Compilation.
- Assemblage.
- Édition de liens.
- Unités de traduction.
- Fichiers objets.
- Tables des symboles.
- Symboles non définis.
- Visibilité des symboles.
- Bibliothèques statiques.
- Bibliothèques partagées.
- Code indépendant de la position.
- Chargement des bibliothèques à l’exécution.
- Édition de liens dynamique.
- Compatibilité de l’ABI.
- Techniques avancées de manipulation des pointeurs
- Arithmétique des pointeurs.
- Tableaux et pointeurs : leurs similitudes et leurs différences.
- Pointeurs de pointeurs (
T **). - Pointeurs vers des tableaux.
- Pointeurs de fonction.
- Pointeurs vers des structures.
- Respect de
const. restrict.void *et programmation générique.- Pointeurs nuls et pointeurs invalides.
- Durée de vie des pointeurs et règles d’aliasing.
- Structures et conception orientée données
- Composition de structures.
- Structures opaques.
- Structures publiques et privées.
- Unions étiquetées.
- Énumérations.
- Champs de bits et leurs limites en matière de portabilité.
- Remplissage et alignement des structures.
- Membres de tableaux flexibles.
- Structures de données intrusives et non intrusives.
- Initialisation des structures.
- Littéraux composés.
- Chaînes de caractères et données binaires en C
- Chaînes terminées par un caractère nul.
- Tableaux de caractères.
- Tailles et capacités des tampons.
strlen(),strcmp(),memcpy()etmemmove().- Construction sûre de chaînes de caractères.
- Tampons de chaînes dynamiques.
- UTF-8.
- Encodage des caractères et représentation en octets.
- Formatage des entiers et spécificateurs de format de
printf(). - Vulnérabilités liées aux chaînes de format.
- Traitement des données binaires.
- Types entiers et comportement indéfini
- Promotions des entiers.
- Opérations arithmétiques signées et non signées.
- Débordement d’entiers.
- Conversions d’entiers.
- Types entiers de largeur fixe (
uint32_t,int64_t, etc.). size_t,ptrdiff_tetuintptr_t.- Boutisme.
- Alignement.
- Comportement indéfini.
- Comportement non spécifié.
- Comportement défini par l’implémentation.
- Règles strictes d’aliasing.
- Gestion des erreurs
- Gestion des erreurs fondée sur les valeurs de retour.
- Codes d’erreur.
- Paramètres de sortie contenant les erreurs.
- Modèle de nettoyage avec
goto.
- Structures de données et algorithmes en C
- Tableaux dynamiques.
- Listes chaînées.
- Listes doublement chaînées.
- Tables de hachage.
- Arbres.
- Arbres binaires de recherche.
- Arbres équilibrés.
- Files.
- Piles.
- Tas.
- Tampons circulaires.
- Constructeurs de chaînes.
- Itérateurs.
- Pointeurs de fonction, fonctions de rappel et polymorphisme
- Enregistrement de fonctions de rappel.
- Pointeurs de fonction.
- Pointeurs de fonction dans les structures.
- Modèles fondés sur des tables de fonctions virtuelles.
- Implémentation d’interfaces.
- Gestionnaires d’événements.
- Pointeurs vers des données utilisateur.
- Interfaces de greffons.
- Distribution dynamique.
- Interface avec le système d’exploitation
- Bibliothèque standard C et API du système d’exploitation.
- POSIX.
- Descripteurs de fichiers.
- Flux de fichiers (
FILE *). - Opérations sur les fichiers.
- Répertoires et chemins.
- Processus.
- Variables d’environnement.
- Tubes.
- Signaux.
- Sockets.
- Mappage mémoire (
mmap()). - Appels système.
- Concurrence et multithreading
- Processus et threads.
- Threads POSIX.
- Mutex.
- Variables de condition.
- Sémaphores.
- Opérations atomiques.
- Courses de données.
- Interblocages.
- Sécurité des threads.
- Stockage local aux threads.
- Ordonnancement de la mémoire.
- Boucles d’événements.
- Programmation asynchrone.
- Programmation pilotée par les événements
- Boucles d’événements.
- Files d’événements.
- Distribution des événements.
- Fonctions de rappel.
- Minuteries.
- Événements d’entrée.
- Événements de fenêtre.
- Opérations asynchrones.
- Cycle de vie de l’application.
- Systèmes de construction
- GNU Make
- Autoconf et Automake
- Meson
- CMake
- Installation des bibliothèques et gestion des dépendances
- Répertoires d’inclusion.
- Répertoires des bibliothèques.
pkg-config.- Fichiers
.pc. PKG_CONFIG_PATH.- Édition de liens statique et dynamique.
- Chemins des bibliothèques à l’exécution.
- Préfixes d’installation.
- Installation des fichiers d’en-tête.
- Gestion des versions des bibliothèques.
- Détection des dépendances.
- Dépendances transitives.
- Débogage
- GDB.
- Points d’arrêt.
- Traces de pile.
- Cadres de pile.
- Inspection des variables.
- Images mémoire.
- Points de surveillance.
- Symboles de débogage.
- Débogage de programmes optimisés.
- Débogage des erreurs de segmentation.
- Détection des erreurs mémoire et des comportements indéfinis
- AddressSanitizer, pour les accès hors limites, les utilisations après libération et d’autres erreurs de mémoire.
- UndefinedBehaviorSanitizer, pour diverses formes de comportement indéfini.
- Valgrind Memcheck, pour les accès mémoire invalides, les valeurs non initialisées et les fuites de mémoire.
- MemorySanitizer, pour l’utilisation de mémoire non initialisée.
- Analyse statique, pour détecter les défauts potentiels sans exécuter le programme.
- Tests logiciels
- Tests unitaires.
- Tests d’intégration.
- Tests de régression.
- Fixtures de test.
- Assertions de test.
- Tests des limites.
- Tests des chemins d’erreur.
- Tests des fuites de mémoire.
- Tests par fuzzing.
- Intégration continue.
- Analyse des performances
- Complexité algorithmique.
- Localité du cache.
- Surcoût de l’allocation mémoire.
- Profilage.
- Profilage du processeur.
- Profilage de la mémoire.
- Tests de performance.
- Optimisation orientée données.
- Conventions de codage et lisibilité
- Conventions de nommage.
- Indentation.
- Organisation des fonctions.
- Organisation des fichiers d’en-tête.
- Commentaires.
- Commentaires de documentation.
- Nommage des symboles publics et privés.
- Organisation des fichiers.
- Éviter les macros inutiles.
- Éviter les variables globales inutiles.
- Préserver la lisibilité des fonctions.
- Maintenir la cohérence.
- Documentation
- Fonctions publiques.
- Paramètres des fonctions.
- Valeurs de retour.
- Conditions d’erreur.
- Transfert de propriété.
- Cycle de vie des objets.
- Garanties de sécurité des threads.
- Stabilité de l’API.
- Exemples d’utilisation.
- Stabilité de l’API et de l’ABI
- Qu’est-ce qu’une API ?
- Qu’est-ce qu’une ABI ?
- Qu’est-ce qui constitue une modification incompatible ?
- Pourquoi l’exposition des membres d’une structure peut poser problème.
- Visibilité des symboles.
- Gestion des versions des bibliothèques partagées.
- Dépréciation.
- Compatibilité ascendante.
- Installation simultanée de différentes versions d’une bibliothèque.
- Internationalisation et localisation
- UTF-8.
- Encodages de caractères.
- Paramètres régionaux.
gettext.- Catalogues de traduction.
- Formes plurielles.
- Formatage des dates et des nombres.
- Traduction des messages d’erreur.
- Éviter les chaînes destinées à l’utilisateur codées en dur.
- Git et développement collaboratif
- Dépôts.
- Commits.
- Branches.
- Fusions.
- Rebasage.
- Inspection des différences.
- Résolution des conflits.
- Création de correctifs.
- Revue de code.
- Signalement des problèmes.
- Branches de publication.
Ou une version simplifiée :
- Étape 1 — C idiomatique
- Propriété et durée de vie de la mémoire.
- Pointeurs et structures avancés.
- Manipulation des chaînes et des tampons.
- Gestion des erreurs.
- Structures de données.
- Pointeurs de fonction et fonctions de rappel.
- Étape 2 — Ingénierie des bibliothèques
- Types opaques et conception d’API.
- Organisation des fichiers d’en-tête et des fichiers source.
- Bibliothèques statiques et partagées.
- Compilation et édition de liens.
pkg-config.- Stabilité de l’ABI et de l’API.
- Étape 3 — Développement professionnel en C
- POSIX et programmation système.
- Systèmes de construction.
- Débogage et profilage.
- Tests unitaires et tests d’intégration.
- Désinfecteurs et analyse statique.
- Documentation et conventions de codage.
- Étape 4 — Développement dans l’écosystème
- GLib et GObject.
- Pratiques de développement GNU.
- Pratiques de développement SDL.
- Git et développement collaboratif.
- Compatibilité des API.
- Contribution de correctifs à des projets établis.