Praktische Beispiele
Eine Logging-Funktion
Praktische Beispiele ist eine kostenlose C Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des C Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der C Academy-Kurs umfasst insgesamt 4 Lektionen.
Eine Logging-Funktion
Ein Logger ist ein idealer praktischer Anwendungsfall für Variadics. Wir möchten log_msg("user %s scored %d", name, score) genau wie printf aufrufen.
In dieser Lektion erstellen Sie ein kleines, nützliches Logging-Programm.
#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;
}Eine Schweregradstufe hinzufügen
Echte Logger kennzeichnen Nachrichten mit einer Stufe wie INFO oder ERROR. Fügen Sie vor dem Format-String einen festen Parameter für die Stufe hinzu.
#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;
}Nachrichten mit Zeitstempeln versehen
Sie können jede Zeile vor der Weiterleitung des Formats um zusätzlichen Kontext ergänzen. Hier stellen wir einen fiktiven Zähler als Ersatz für einen Zeitstempel voran.
#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;
}In stderr protokollieren
Fehler und Diagnosemeldungen werden üblicherweise nach stderr ausgegeben. Verwenden Sie vfprintf(stderr, fmt, args), damit sich die Logausgabe nicht mit der normalen Programmausgabe vermischt.
#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;
}Bedingtes Logging
Mit einem Schwellenwert für die Ausführlichkeit können Sie Nachrichten niedriger Priorität unterdrücken. Vergleichen Sie die Nachrichtenstufe vor der Ausgabe mit einem konfigurierten Mindestwert.
#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;
}Eine Nachrichten-Zeichenkette erstellen
Manchmal möchten Sie den formatierten Text in einem Puffer haben, statt ihn auszugeben. Verwenden Sie vsnprintf, um ihn zu erzeugen, und entscheiden Sie anschließend, was damit geschehen soll.
#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;
}Eine variadische Max-Funktion
Variadics eignen sich auch für mathematische Hilfsfunktionen. Hier ist eine Funktion, die mit einem Zählparameter die größte von mehreren Ganzzahlen zurückgibt.
#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;
}Zeichenketten verketten
Mit einem NULL-Sentinel können wir beliebig viele Zeichenketten zu einem Puffer zusammenfügen.
#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;
}Variadische Ganzzahlen zählen
Ein Sentinel-basierter Zähler zeigt, wie flexibel dieses Muster ist. Wir zählen Werte, bis wir die abschließende 0 erreichen.
#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;
}Als Makro verpacken
Ein gängiger Trick ist ein Makro, das die Stufe automatisch einsetzt, sodass die Aufrufer weniger schreiben müssen. Das Makro leitet an die eigentliche variadische Funktion weiter.
#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;
}Den Logger einsetzen
Hier ist ein vollständiger Mini-Logger, der eine Stufe und einen Zeitstempelzähler kombiniert und direkt in ein Programm übernommen werden kann.
#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;
}Kurzer Test
Testen Sie Ihr Verständnis des Entwurfs variadischen Loggings.
Zusammenfassung
Sie haben praktische variadische Werkzeuge erstellt:
- Einen Logger, der sein Format an
vprintf/vfprintfweiterleitet. - Sie haben Stufen, Zähler, stderr-Ausgabe und bedingte Filterung hinzugefügt.
- Sie haben
vsnprintfverwendet, um Nachrichten in Puffern abzulegen. - Sie haben Sentinel-basierte Hilfsfunktionen und ein praktisches Makro als Wrapper kennengelernt.
Lerne C mit einem KI-Tutor — kostenlos
Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.
- Kurse
- 39
- Lektionen
- 144
Häufig gestellte Fragen
Ist die Lektion „Praktische Beispiele“ kostenlos?
Ja — der vollständige Text von „Praktische Beispiele“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des C Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der C Academy-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Praktische Beispiele“?
Eine Logging-Funktion Du übst C Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um C Academy zu starten?
Keine Vorkenntnisse erforderlich. C Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.
Wie lange dauert die Lektion „Praktische Beispiele“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser C Academy-Lektion Code schreiben und ausführen?
Ja. Jede C Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Die stdarg-Makros
- Printf-ähnliche Funktionen schreiben
- Fragen der Typsicherheit
- Praktische Beispiele