Printf-ähnliche Funktionen schreiben
Variable Argumente
Printf-ähnliche Funktionen schreiben ist eine kostenlose C Academy-Lektion auf CoddyKit. Dies ist Lektion 2 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.
Funktionen mit einem Format-String
Die leistungsfähigste Verwendung von Variadics besteht darin, Funktionen im Stil von printf zu erstellen, die einen Format-String interpretieren.
Das Format teilt der Funktion mit, wie viele Argumente folgen und welchen Typ jedes einzelne hat.
#include <stdio.h>
#include <stdarg.h>
void myprint(const char *fmt, ...) {
printf("format was: %s\n", fmt);
}
int main(void) {
myprint("%d items\n", 5);
return 0;
}Den Format-String durchlaufen
Durchsuchen Sie den Format-String Zeichen für Zeichen. Wenn Sie ein % sehen, ist das nächste Zeichen ein Konvertierungsbezeichner, der angibt, welchen Typ Sie lesen müssen.
Alles andere wird wörtlich ausgegeben.
#include <stdio.h>
#include <stdarg.h>
void scan(const char *fmt) {
for (const char *p = fmt; *p; p++) {
if (*p == '%') printf("[spec:%c]", *(p+1));
else putchar(*p);
}
putchar('\n');
}
int main(void) {
scan("x=%d y=%s");
return 0;
}Den passenden Typ lesen
Wenn der Bezeichner %d lautet, lesen Sie ein int. Bei %s lesen Sie einen char *. Das Format muss exakt zu den tatsächlichen Argumenten passen.
#include <stdio.h>
#include <stdarg.h>
void mini(const char *fmt, ...) {
va_list args;
va_start(args, fmt);
for (const char *p = fmt; *p; p++) {
if (*p == '%' && *(p+1) == 'd') {
printf("%d", va_arg(args, int));
p++;
} else putchar(*p);
}
va_end(args);
}
int main(void) {
mini("count=%d\n", 42);
return 0;
}Mehrere Bezeichner verarbeiten
Erweitern Sie den Scanner, sodass er mehrere Konvertierungen verarbeitet. Fügen Sie Fälle für %d, %s und %c hinzu und lesen Sie jeweils den passenden Typ.
#include <stdio.h>
#include <stdarg.h>
void fmt_print(const char *fmt, ...) {
va_list args;
va_start(args, fmt);
for (const char *p = fmt; *p; p++) {
if (*p != '%') { putchar(*p); continue; }
p++;
if (*p == 'd') printf("%d", va_arg(args, int));
else if (*p == 's') printf("%s", va_arg(args, char *));
else if (*p == 'c') putchar(va_arg(args, int));
}
va_end(args);
}
int main(void) {
fmt_print("%s is %d\n", "age", 30);
return 0;
}Das Prozentzeichen maskieren
Echte Formatfunktionen behandeln %% als wörtliches Prozentzeichen. Fügen Sie einen Fall hinzu, damit Benutzer ein tatsächliches % ausgeben können.
#include <stdio.h>
#include <stdarg.h>
void fp(const char *fmt, ...) {
va_list args;
va_start(args, fmt);
for (const char *p = fmt; *p; p++) {
if (*p == '%') {
p++;
if (*p == '%') putchar('%');
else if (*p == 'd') printf("%d", va_arg(args, int));
} else putchar(*p);
}
va_end(args);
}
int main(void) {
fp("%d%% done\n", 75);
return 0;
}An vprintf weiterleiten
Oft möchten Sie die Formatierung nicht selbst neu implementieren. Die Standardbibliothek bietet vprintf, das direkt eine va_list entgegennimmt.
Ihre Wrapper-Funktion reicht ihre Argumente einfach weiter.
#include <stdio.h>
#include <stdarg.h>
void logline(const char *fmt, ...) {
va_list args;
va_start(args, fmt);
vprintf(fmt, args);
va_end(args);
}
int main(void) {
logline("value = %d, name = %s\n", 7, "box");
return 0;
}Ein Präfix hinzufügen
Mit dem vprintf-Ansatz können Sie das Verhalten der Standardformatierung leicht erweitern, etwa indem Sie vor jeder Nachricht ein Tag ausgeben.
#include <stdio.h>
#include <stdarg.h>
void info(const char *fmt, ...) {
printf("[INFO] ");
va_list args;
va_start(args, fmt);
vprintf(fmt, args);
va_end(args);
}
int main(void) {
info("server started on port %d\n", 8080);
return 0;
}Mit vsnprintf in einen Puffer schreiben
Um eine Zeichenkette zu formatieren, statt sie auszugeben, verwenden Sie vsnprintf(buf, size, fmt, args).
Die Funktion wird durch size begrenzt, verhindert dadurch einen Überlauf und beendet die Zeichenkette immer mit einem Nullzeichen.
#include <stdio.h>
#include <stdarg.h>
void format_into(char *buf, size_t n, const char *fmt, ...) {
va_list args;
va_start(args, fmt);
vsnprintf(buf, n, fmt, args);
va_end(args);
}
int main(void) {
char out[64];
format_into(out, sizeof(out), "id-%d", 123);
printf("%s\n", out);
return 0;
}Eine Länge zurückgeben
vsnprintf gibt die Anzahl der Zeichen zurück, die hätten geschrieben werden sollen. Damit können Sie eine Kürzung erkennen oder die Größe eines Puffers bestimmen.
#include <stdio.h>
#include <stdarg.h>
int build(char *buf, size_t n, const char *fmt, ...) {
va_list args;
va_start(args, fmt);
int len = vsnprintf(buf, n, fmt, args);
va_end(args);
return len;
}
int main(void) {
char b[10];
int needed = build(b, sizeof(b), "%d-%d", 11, 22);
printf("%s (needed %d)\n", b, needed);
return 0;
}Den Ansatz auswählen
Es gibt zwei Strategien: Parsen Sie das Format selbst, wenn Sie vollständige Kontrolle benötigen, oder leiten Sie es für korrekte Ergebnisse und weniger Code an vprintf/vsnprintf weiter.
Für den meisten produktiven Code ist die Weiterleitung die sicherere und einfachere Wahl.
#include <stdio.h>
#include <stdarg.h>
void say(const char *fmt, ...) {
va_list args;
va_start(args, fmt);
vfprintf(stdout, fmt, args);
va_end(args);
}
int main(void) {
say("%s = %.1f\n", "pi", 3.14);
return 0;
}Nichtübereinstimmung ist undefiniert
Wenn der Format-String einen Typ angibt, der nicht zum tatsächlichen Argument passt, ist das Verhalten undefiniert.
printf("%d", "text") kann abstürzen. Achten Sie immer darauf, dass Format und Argumente übereinstimmen.
#include <stdio.h>
int main(void) {
int n = 5;
printf("%d\n", n);
return 0;
}Kurzer Test
Testen Sie Ihr Verständnis von Wrapper-Funktionen im printf-Stil.
Zusammenfassung
Sie haben gelernt, Funktionen im Stil von printf zu erstellen:
- Verwenden Sie einen Format-String als benannten Parameter, gefolgt von
.... - Parsen Sie entweder die
%-Bezeichner selbst und lesen Sie die passenden Typen, oder - leiten Sie die
va_listfür eine sichere und korrekte Formatierung an vprintf / vsnprintf weiter. - Halten Sie Format und Argumenttypen synchron, um undefiniertes Verhalten zu vermeiden.
Häufig gestellte Fragen
Ist die Lektion „Printf-ähnliche Funktionen schreiben“ kostenlos?
Ja — der vollständige Text von „Printf-ähnliche Funktionen schreiben“ 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 „Printf-ähnliche Funktionen schreiben“?
Variable Argumente 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 2 von 4.
Wie lange dauert die Lektion „Printf-ähnliche Funktionen schreiben“?
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