C Academy · Lektion

strtok und Tokenizing

Strings aufteilen

strtok und Tokenizing ist eine kostenlose C Academy-Lektion auf CoddyKit. Dies ist Lektion 3 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.

Was ist Tokenisierung?

Tokenisierung bedeutet, eine Zeichenkette anhand von Trennzeichen in kleinere Teile (Token) aufzuteilen.

Beim Aufteilen von "a,b,c" an Kommas entstehen beispielsweise die Token a, b und c. C stellt dafür strtok bereit.

#include <stdio.h>
#include <string.h>

int main(void) {
    char text[] = "a,b,c";
    char *token = strtok(text, ",");
    printf("First token: %s\n", token);
    return 0;
}

Die Signatur von strtok

char *strtok(char *str, const char *delim);

Beim ersten Aufruf übergeben Sie die Zeichenkette. Bei folgenden Aufrufen übergeben Sie NULL, damit die Verarbeitung an der bisherigen Position fortgesetzt wird. Die Funktion gibt das nächste Token oder nach Abschluss NULL zurück.

#include <stdio.h>
#include <string.h>

int main(void) {
    char text[] = "red green blue";
    char *tok = strtok(text, " ");
    while (tok != NULL) {
        printf("%s\n", tok);
        tok = strtok(NULL, " ");
    }
    return 0;
}

strtok verändert die Zeichenkette

Wichtig: strtok verändert die ursprüngliche Zeichenkette. Jedes Trennzeichen wird durch '\0' ersetzt, und die Funktion gibt Zeiger in denselben Puffer zurück.

Deshalb können Sie keine Zeichenkettenkonstante wie "a,b" tokenisieren, da sie schreibgeschützt ist.

#include <stdio.h>
#include <string.h>

int main(void) {
    char data[] = "x:y:z";
    strtok(data, ":");
    printf("data[1] is now: %d (the null byte)\n", data[1]);
    return 0;
}

Eine beschreibbare Kopie erstellen

Da strtok seine Eingabe zerstört, kopieren Sie die Zeichenkette zuerst, wenn Sie das Original später noch benötigen.

Verwenden Sie ein lokales char-Array oder kopieren Sie die Zeichenkette mit strcpy in einen Puffer.

#include <stdio.h>
#include <string.h>

int main(void) {
    const char *original = "one-two-three";
    char copy[64];
    strcpy(copy, original);
    char *tok = strtok(copy, "-");
    while (tok) {
        printf("%s\n", tok);
        tok = strtok(NULL, "-");
    }
    printf("Original intact: %s\n", original);
    return 0;
}

Mehrere Trennzeichen

Das Argument delim ist eine Menge von Zeichen, keine Zeichenfolge. Jedes Zeichen aus dieser Menge dient als Trennzeichen.

" ,;" teilt die Zeichenkette daher gleichzeitig an Leerzeichen, Kommas und Semikolons auf.

#include <stdio.h>
#include <string.h>

int main(void) {
    char text[] = "a,b;c d";
    char *tok = strtok(text, ",; ");
    while (tok) {
        printf("[%s]\n", tok);
        tok = strtok(NULL, ",; ");
    }
    return 0;
}

Aufeinanderfolgende Trennzeichen

strtok behandelt Folgen von Trennzeichen als ein einziges Trennzeichen und überspringt leere Token.

"a,,b" ergibt daher nur a und b, nicht ein leeres Token dazwischen. Beachten Sie das beim Parsen von CSV, wenn leere Felder von Bedeutung sind.

#include <stdio.h>
#include <string.h>

int main(void) {
    char text[] = "a,,b";
    char *tok = strtok(text, ",");
    while (tok) {
        printf("token: %s\n", tok);
        tok = strtok(NULL, ",");
    }
    return 0;
}

Token zählen

Eine häufige Aufgabe besteht darin, zu zählen, wie viele Token eine Zeichenkette enthält. Erhöhen Sie dazu innerhalb der Schleife einen Zähler.

#include <stdio.h>
#include <string.h>

int main(void) {
    char sentence[] = "the quick brown fox";
    int count = 0;
    char *tok = strtok(sentence, " ");
    while (tok) {
        count++;
        tok = strtok(NULL, " ");
    }
    printf("Word count: %d\n", count);
    return 0;
}

strtok speichert einen verborgenen Zustand

strtok speichert seine Position in einer statischen internen Variable. Deshalb wird die vorherige Zeichenkette mit NULL fortgesetzt.

Der Nachteil: Die Funktion ist nicht wiedereintrittsfähig und nicht threadsicher. Sie können nicht zwei Zeichenketten gleichzeitig tokenisieren.

#include <stdio.h>
#include <string.h>

int main(void) {
    char a[] = "1 2";
    char *t = strtok(a, " ");
    printf("%s\n", t);
    t = strtok(NULL, " ");
    printf("%s\n", t);
    return 0;
}

Token speichern

Um Token nach dem Aufteilen zu verwenden, speichern Sie die zurückgegebenen Zeiger in einem Array. Sie zeigen in den (nun veränderten) Quellpuffer, der weiterhin gültig sein muss.

#include <stdio.h>
#include <string.h>

int main(void) {
    char csv[] = "name,age,city";
    char *fields[10];
    int n = 0;
    char *tok = strtok(csv, ",");
    while (tok && n < 10) {
        fields[n++] = tok;
        tok = strtok(NULL, ",");
    }
    for (int i = 0; i < n; i++)
        printf("Field %d: %s\n", i, fields[i]);
    return 0;
}

Die wiedereintrittsfähige Alternative

POSIX bietet strtok_r, das statt eines verborgenen Zustands einen expliziten char **saveptr übernimmt. Dadurch kann die Funktion sicher verschachtelt und in mehreren Threads verwendet werden.

Für portables Standard-C ist das einfache strtok beim Parsen in einem einzigen Durchlauf geeignet.

#include <stdio.h>
#include <string.h>

int main(void) {
    char text[] = "p:q:r";
    char *save;
    char *tok = strtok_r(text, ":", &save);
    while (tok) {
        printf("%s\n", tok);
        tok = strtok_r(NULL, ":", &save);
    }
    return 0;
}

Praxis: Einen Pfad aufteilen

Beim Parsen strukturierter Texte wie Dateipfaden ist die Tokenisierung besonders nützlich. Durch das Aufteilen an / wird jede Pfadkomponente sichtbar.

#include <stdio.h>
#include <string.h>

int main(void) {
    char path[] = "usr/local/bin";
    char *part = strtok(path, "/");
    while (part) {
        printf("-> %s\n", part);
        part = strtok(NULL, "/");
    }
    return 0;
}

Schnelltest

Testen Sie Ihr Verständnis der Funktionsweise von strtok.

Zusammenfassung

Sie haben gelernt, Zeichenketten mit strtok aufzuteilen:

Der erste Aufruf übernimmt die Zeichenkette, spätere Aufrufe übernehmen NULL.
Die Funktion verändert die Eingabe und ersetzt Trennzeichen durch '\0' — kopieren Sie schreibgeschützte Zeichenketten vorher.
Das Trennzeichenargument ist eine Menge; aufeinanderfolgende Trennzeichen werden zusammengefasst.
Die Funktion verwendet einen statischen Zustand und ist nicht threadsicher; verwenden Sie bei Bedarf strtok_r.

Häufig gestellte Fragen

Ist die Lektion „strtok und Tokenizing“ kostenlos?

Ja — der vollständige Text von „strtok und Tokenizing“ 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 „strtok und Tokenizing“?

Strings aufteilen 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 3 von 4.

Wie lange dauert die Lektion „strtok und Tokenizing“?

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

← Zurück zu C Academy