0Pricing
C Academy · Leçon

strtok et tokenisation

Découpez des chaînes

strtok et tokenisation est une leçon C Academy gratuite sur CoddyKit. Ceci est la leçon 3 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.

Qu’est-ce que la tokenisation ?

La tokenisation consiste à diviser une chaîne en morceaux plus petits (des jetons) séparés par des caractères délimiteurs.

Par exemple, diviser "a,b,c" sur les virgules donne les jetons a, b et c. C fournit strtok pour cela.

#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;
}

La signature de strtok

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

Lors du premier appel, vous transmettez la chaîne. Lors des appels suivants, vous transmettez NULL afin de reprendre là où l’exécution s’était arrêtée. La fonction renvoie le jeton suivant, ou NULL lorsqu’il n’y en a plus.

#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 modifie la chaîne

Important : strtok modifie la chaîne d’origine. Elle remplace chaque délimiteur par '\0' et renvoie des pointeurs vers le même tampon.

Vous ne pouvez donc pas tokeniser un littéral de chaîne comme "a,b", qui est en lecture seule.

#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;
}

Créer une copie modifiable

Comme strtok détruit son entrée, copiez d’abord la chaîne si vous devez conserver l’originale.

Utilisez un tableau local de char ou copiez-la avec strcpy dans un tampon.

#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;
}

Plusieurs délimiteurs

L’argument delim est un ensemble de caractères, et non une séquence. Tout caractère de cet ensemble agit comme un séparateur.

Ainsi, " ,;" divise simultanément sur les espaces, les virgules et les points-virgules.

#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;
}

Délimiteurs consécutifs

strtok traite les suites de délimiteurs comme un seul séparateur et ignore les jetons vides.

Ainsi, "a,,b" produit uniquement a et b, sans jeton vide entre les deux. Gardez cela à l’esprit pour l’analyse de CSV, où les champs vides sont importants.

#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;
}

Compter les jetons

Une tâche courante consiste à compter le nombre de jetons que contient une chaîne. Incrémentez un compteur à l’intérieur de la boucle.

#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 conserve un état caché

strtok stocke sa position dans une variable interne statique. C’est pourquoi NULL permet de poursuivre le traitement de la chaîne précédente.

Inconvénient : cette fonction n’est pas réentrante et n’est pas sûre pour les threads. Vous ne pouvez pas tokeniser deux chaînes simultanément.

#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;
}

Stocker les jetons

Pour utiliser les jetons après la division, stockez les pointeurs renvoyés dans un tableau. Ils pointent vers le tampon source, désormais modifié, qui doit rester valide.

#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;
}

L’alternative réentrante

POSIX propose strtok_r, qui reçoit un char **saveptr explicite au lieu d’un état caché. Cela permet de l’imbriquer et de l’utiliser en toute sécurité entre plusieurs threads.

Pour du C standard portable, le simple strtok convient à une analyse en un seul passage.

#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;
}

En pratique : diviser un chemin

La tokenisation est particulièrement utile pour analyser du texte structuré, comme des chemins de fichiers. Diviser sur / révèle chaque composant du chemin.

#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;
}

Vérification rapide

Vérifiez votre compréhension du fonctionnement de strtok.

Récapitulatif

Vous avez appris à diviser des chaînes avec strtok :

  • Le premier appel reçoit la chaîne ; les appels suivants reçoivent NULL.
  • La fonction modifie l’entrée en remplaçant les délimiteurs par '\0' — copiez d’abord les chaînes en lecture seule.
  • L’argument délimiteur est un ensemble ; les délimiteurs consécutifs sont regroupés.
  • La fonction utilise un état statique et n’est pas sûre pour les threads ; utilisez strtok_r si nécessaire.

Questions Fréquemment Posées

La leçon « strtok et tokenisation » est-elle gratuite ?

Oui — le texte complet de « strtok et tokenisation » 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 « strtok et tokenisation » ?

Découpez des chaînes 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 3 sur 4.

Combien de temps prend la leçon « strtok et tokenisation » ?

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

  1. strlen, strcpy, strcat
  2. strcmp et comparaison
  3. strtok et tokenisation
  4. memcpy et memset
← Retour à C Academy