0Pricing
C Academy · Aula

strtok e tokenização

Divida strings.

strtok e tokenização é uma aula grátis de C Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de C Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de C Academy inclui 4 aulas no total.

O que é tokenização?

Tokenização significa dividir uma string em partes menores (tokens) separadas por caracteres delimitadores.

Por exemplo, dividir "a,b,c" nas vírgulas produz os tokens a, b e c. C oferece strtok para isso.

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

A assinatura de strtok

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

Na primeira chamada, passe a string. Nas chamadas seguintes, passe NULL para continuar de onde parou. A função retorna o próximo token ou NULL quando termina.

#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 modifica a string

Importante: strtok altera a string original. Ela substitui cada delimitador por '\0' e retorna ponteiros para dentro do mesmo buffer.

Isso significa que você não pode tokenizar um literal de string como "a,b", que é somente leitura.

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

Crie uma cópia gravável

Como strtok destrói sua entrada, copie a string primeiro se precisar do original mais tarde.

Use um vetor local de char ou copie com strcpy para um buffer.

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

Vários delimitadores

O argumento delim é um conjunto de caracteres, não uma sequência. Qualquer caractere do conjunto atua como separador.

Assim, " ,;" divide nos espaços, nas vírgulas e nos pontos e vírgulas de uma só vez.

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

Delimitadores consecutivos

strtok trata sequências de delimitadores como um único separador e ignora tokens vazios.

Assim, "a,,b" produz apenas a e b, sem um token vazio entre eles. Tenha isso em mente ao analisar CSV, em que campos vazios são importantes.

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

Contando tokens

Uma tarefa comum é contar quantos tokens uma string contém. Incremente um contador dentro do laço.

#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 mantém estado oculto

strtok armazena sua posição em uma variável interna estática. É por isso que NULL continua a string anterior.

A desvantagem é que ela não é reentrante nem segura para uso em threads. Você não pode tokenizar duas strings ao mesmo tempo.

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

Armazenando tokens

Para usar os tokens depois da divisão, armazene os ponteiros retornados em um vetor. Eles apontam para dentro do buffer de origem (agora modificado), que deve continuar válido.

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

A alternativa reentrante

POSIX oferece strtok_r, que recebe um char **saveptr explícito em vez de usar estado oculto. Isso torna a função segura para aninhamento e uso entre threads.

Para C padrão portável, o strtok comum é adequado para análise em uma única passagem.

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

Prática: dividindo um caminho

A tokenização é especialmente útil ao analisar textos estruturados, como caminhos de arquivos. Dividir usando / revela cada componente do caminho.

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

Verificação rápida

Teste sua compreensão de como strtok funciona.

Revisão

Você aprendeu a dividir strings com strtok:

  • A primeira chamada recebe a string; as chamadas seguintes recebem NULL.
  • Ela modifica a entrada, substituindo delimitadores por '\0' — copie primeiro as strings somente para leitura.
  • O argumento delimitador é um conjunto; delimitadores consecutivos são agrupados.
  • Ela usa estado estático e não é segura para uso em threads; use strtok_r quando necessário.

Perguntas Frequentes

A aula “strtok e tokenização” é grátis?

Sim — o texto completo de “strtok e tokenização” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de C Academy, atualize para CoddyKit PRO. O curso de C Academy inclui 4 aulas no total.

O que vou aprender em “strtok e tokenização”?

Divida strings. Você pratica C Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar C Academy?

Nenhuma experiência prévia é necessária. C Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “strtok e tokenização”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de C Academy?

Sim. Cada aula de C Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. strlen, strcpy, strcat
  2. strcmp e comparação
  3. strtok e tokenização
  4. memcpy e memset
← Voltar para C Academy