Exemples pratiques
Une fonction de journalisation
Exemples pratiques est une leçon C Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C Academy comprend 4 leçons au total.
Une fonction de journalisation
Un outil de journalisation est un exemple d’utilisation concret idéal des fonctions variadiques. Nous voulons pouvoir appeler log_msg("user %s scored %d", name, score), comme avec printf.
Cette leçon crée un petit outil de journalisation pratique.
#include <stdio.h>
#include <stdarg.h>
void log_msg(const char *fmt, ...) {
va_list a; va_start(a, fmt);
vprintf(fmt, a);
va_end(a);
printf("\n");
}
int main(void) {
log_msg("user %s scored %d", "Ann", 90);
return 0;
}Ajouter un niveau de gravité
Les outils de journalisation réels attribuent aux messages un niveau comme INFO ou ERROR. Ajoutez un paramètre fixe avant la chaîne de format pour représenter ce niveau.
#include <stdio.h>
#include <stdarg.h>
void logf(const char *level, const char *fmt, ...) {
printf("[%s] ", level);
va_list a; va_start(a, fmt);
vprintf(fmt, a);
va_end(a);
printf("\n");
}
int main(void) {
logf("INFO", "started with %d workers", 4);
return 0;
}Ajouter un horodatage aux messages
Vous pouvez enrichir chaque ligne avec un contexte supplémentaire avant de transmettre le format. Ici, nous ajoutons au début un compteur fictif qui sert de substitut à un horodatage.
#include <stdio.h>
#include <stdarg.h>
static int line_no = 0;
void logf(const char *fmt, ...) {
printf("#%d ", ++line_no);
va_list a; va_start(a, fmt);
vprintf(fmt, a);
va_end(a);
printf("\n");
}
int main(void) {
logf("first %s", "event");
logf("value %d", 7);
return 0;
}Journaliser dans stderr
Les erreurs et les informations de diagnostic sont généralement envoyées vers stderr. Utilisez vfprintf(stderr, fmt, args) afin que la sortie de journalisation ne soit pas mélangée à la sortie normale du programme.
#include <stdio.h>
#include <stdarg.h>
void err(const char *fmt, ...) {
fprintf(stderr, "ERROR: ");
va_list a; va_start(a, fmt);
vfprintf(stderr, fmt, a);
va_end(a);
fprintf(stderr, "\n");
}
int main(void) {
err("failed to open %s", "data.txt");
return 0;
}Journalisation conditionnelle
Un seuil de verbosité permet de supprimer les messages de faible priorité. Comparez le niveau du message à un minimum configuré avant de l’afficher.
#include <stdio.h>
#include <stdarg.h>
static int min_level = 2;
void logf(int level, const char *fmt, ...) {
if (level < min_level) return;
va_list a; va_start(a, fmt);
vprintf(fmt, a);
va_end(a);
printf("\n");
}
int main(void) {
logf(1, "debug hidden");
logf(3, "important %d", 42);
return 0;
}Construire une chaîne de message
Vous pouvez parfois vouloir placer le texte formaté dans un tampon plutôt que l’afficher. Utilisez vsnprintf pour le produire, puis choisissez quoi en faire.
#include <stdio.h>
#include <stdarg.h>
void capture(const char *fmt, ...) {
char buf[128];
va_list a; va_start(a, fmt);
vsnprintf(buf, sizeof(buf), fmt, a);
va_end(a);
printf("captured: %s\n", buf);
}
int main(void) {
capture("id=%d name=%s", 5, "box");
return 0;
}Une fonction max variadique
Les fonctions variadiques sont également utiles pour les opérations mathématiques. Voici une fonction qui renvoie le plus grand de plusieurs entiers, à l’aide d’un paramètre de comptage.
#include <stdio.h>
#include <stdarg.h>
int max_of(int count, ...) {
va_list a; va_start(a, count);
int best = va_arg(a, int);
for (int i = 1; i < count; i++) {
int v = va_arg(a, int);
if (v > best) best = v;
}
va_end(a);
return best;
}
int main(void) {
printf("%d\n", max_of(4, 3, 9, 2, 7));
return 0;
}Concaténer des chaînes
En utilisant une sentinelle NULL, nous pouvons réunir un nombre quelconque de chaînes dans un seul tampon.
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
void join(char *out, const char *first, ...) {
out[0] = '\0';
va_list a; va_start(a, first);
const char *s = first;
while (s) { strcat(out, s); s = va_arg(a, const char *); }
va_end(a);
}
int main(void) {
char buf[64];
join(buf, "a", "b", "c", (char *)NULL);
printf("%s\n", buf);
return 0;
}Compter des entiers variadiques
Un compteur fondé sur une sentinelle montre à quel point ce schéma est flexible. Nous comptons les valeurs jusqu’à rencontrer un 0 de terminaison.
#include <stdio.h>
#include <stdarg.h>
int count_until_zero(int first, ...) {
va_list a; va_start(a, first);
int n = 0, v = first;
while (v != 0) { n++; v = va_arg(a, int); }
va_end(a);
return n;
}
int main(void) {
printf("%d\n", count_until_zero(5, 6, 7, 0));
return 0;
}L’encapsuler dans une macro
Une astuce courante consiste à utiliser une macro qui renseigne automatiquement le niveau, afin que les appelants aient moins de code à écrire. La macro transmet les arguments à la véritable fonction variadique.
#include <stdio.h>
#include <stdarg.h>
void real_log(const char *lvl, const char *fmt, ...) {
printf("[%s] ", lvl);
va_list a; va_start(a, fmt);
vprintf(fmt, a);
va_end(a);
printf("\n");
}
#define LOG_INFO(...) real_log("INFO", __VA_ARGS__)
int main(void) {
LOG_INFO("ready in %d ms", 50);
return 0;
}Mettre l’outil de journalisation en pratique
Voici un mini-outil de journalisation complet combinant un niveau et un compteur d’horodatage, prêt à être intégré à un programme.
#include <stdio.h>
#include <stdarg.h>
static int seq = 0;
void mylog(const char *lvl, const char *fmt, ...) {
printf("%04d [%s] ", ++seq, lvl);
va_list a; va_start(a, fmt);
vprintf(fmt, a);
va_end(a);
printf("\n");
}
int main(void) {
mylog("INFO", "boot ok");
mylog("WARN", "low memory: %d MB", 64);
return 0;
}Vérification rapide
Vérifiez votre compréhension de la conception d’outils de journalisation variadiques.
Récapitulatif
Vous avez créé des outils variadiques pratiques :
- Un outil de journalisation qui transmet son format à
vprintf/vfprintf. - Vous avez ajouté des niveaux, des compteurs, une sortie vers stderr et un filtrage conditionnel.
- Vous avez utilisé
vsnprintfpour capturer les messages dans des tampons. - Vous avez découvert des fonctions auxiliaires fondées sur des sentinelles et une macro d’encapsulation pratique.
Questions Fréquemment Posées
La leçon « Exemples pratiques » est-elle gratuite ?
Oui — le texte complet de « Exemples pratiques » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C Academy, passe à CoddyKit PRO. Le cours C Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Exemples pratiques » ?
Une fonction de journalisation Tu pratiques C Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer C Academy ?
Aucune expérience préalable n'est requise. C Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.
Combien de temps prend la leçon « Exemples pratiques » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon C Academy ?
Oui. Chaque leçon C Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Macros stdarg
- Écrire des fonctions semblables à printf
- Problèmes de sûreté des types
- Exemples pratiques