C Classificar Caracteres (ctype.h)

"O CEP só tem algarismos?" "A senha tem pelo menos uma maiúscula?" "Esta resposta começa com S ou s?" Programas fazem perguntas assim o tempo todo, um caractere de cada vez. Dá para responder com contas na tabela ASCII, como em Caracteres (c >= '0' && c <= '9'), mas o C já traz as perguntas prontas, com nomes que se leem como frases: isdigit(c), "é algarismo?"; isupper(c), "é maiúscula?". Elas moram no cabeçalho <ctype.h> (de character type, "tipo de caractere"), junto com toupper e tolower, que trocam maiúscula e minúscula do jeito certo.

Todos os programas foram compilados com o gcc 15.2 na máquina fictícia da Ana (usuária ana, computador notebook), na pasta ~/c, com o comando padrão do guia: gcc -std=c23 -Wall -Wextra arquivo.c -o programa. Antes desta aula, veja Caracteres e Strings: aqui vamos percorrer strings letra por letra.

A ideia: a triagem dos Correios

Na agência dos Correios, cada pacote passa por uma esteira, e um funcionário faz perguntas simples: "é carta ou caixa?", "é para o Sul?", "é registrado?". Cada pergunta tem resposta sim ou não, e ele não precisa abrir o pacote para responder.

As funções is… do ctype.h são esse funcionário. Você entrega um caractere e faz uma pergunta. O nome de cada função é a pergunta em inglês: is ("é") + a categoria. isdigit = "is digit?", "é algarismo?". A resposta é um número: 0 quer dizer não; qualquer outro valor quer dizer sim (como no if, aula if e else).

1. A primeira pergunta: isdigit

#include <ctype.h>
#include <stdio.h>

int main(void) {
    char c = '7';
    if (isdigit(c)) {
        printf("'%c' é um algarismo\n", c);
    } else {
        printf("'%c' não é um algarismo\n", c);
    }
    return 0;
}

#include <ctype.h>

Traz as funções de caractere. Sem ele, o compilador não conhece isdigit (veja "Quando dá errado").

isdigit(c)

"O caractere c é um dos algarismos '0' a '9'?" Devolve um número diferente de zero para sim e 0 para não.

if (isdigit(c))

O if testa direto o resultado: diferente de zero é verdadeiro. É assim que se usa, sem comparar com nada.

$ gcc -std=c23 -Wall -Wextra digito.c -o digito
$ ./digito
'7' é um algarismo

O "sim" não é 1

Que número é esse "diferente de zero"? Vamos olhar:

#include <ctype.h>
#include <stdio.h>

int main(void) {
    printf("isdigit('7') = %d\n", isdigit('7'));
    printf("isdigit('x') = %d\n", isdigit('x'));
    printf("isalpha('x') = %d\n", isalpha('x'));
    printf("isupper('A') = %d\n", isupper('A'));
    printf("isspace(' ') = %d\n", isspace(' '));
    return 0;
}

$ gcc -std=c23 -Wall -Wextra valor.c -o valor
$ ./valor
isdigit('7') = 2048
isdigit('x') = 0
isalpha('x') = 1024
isupper('A') = 256
isspace(' ') = 8192

2048, 1024, 256… A norma do C só promete "zero ou diferente de zero". A biblioteca do Linux (a glibc) guarda as categorias de cada caractere como bits de um número (aula Máscaras de Bits) e devolve o bit da pergunta. No editor do guia, a biblioteca é outra e o mesmo programa mostra 1 em todas as respostas "sim". Os dois estão certos. A lição:

#include <ctype.h>
#include <stdio.h>

int main(void) {
    char c = 'k';
    if (isdigit((unsigned char) c)) {
        printf("'%c' é um algarismo\n", c);
    } else {
        printf("'%c' não é um algarismo\n", c);
    }
    return 0;
}

#include <ctype.h>
#include <stdio.h>

int main(void) {
    char c = 'k';
    if (isalpha((unsigned char) c)) {
        printf("'%c' é uma letra\n", c);
    } else {
        printf("'%c' não é uma letra\n", c);
    }
    return 0;
}

O (unsigned char) antes do c é um cuidado que todo programa com ctype.h deve ter. Por enquanto, aceite; a seção 5 explica o porquê.

2. A família completa

Todas as funções is… recebem um caractere e devolvem zero (não) ou diferente de zero (sim). Para os caracteres da tabela ASCII, as respostas são estas:

Para ver várias perguntas de uma vez, este programa passa por cada caractere de um texto e responde sete delas:

#include <ctype.h>
#include <stdio.h>

int main(void) {
    char texto[] = "Ana, 29 anos!";
    printf("char alpha digit alnum space upper lower punct\n");
    for (int i = 0; texto[i] != '\0'; i++) {
        unsigned char c = texto[i];
        printf(" '%c'  %3s   %3s   %3s   %3s   %3s   %3s   %3s\n", c,
               isalpha(c) ? "sim" : "-",
               isdigit(c) ? "sim" : "-",
               isalnum(c) ? "sim" : "-",
               isspace(c) ? "sim" : "-",
               isupper(c) ? "sim" : "-",
               islower(c) ? "sim" : "-",
               ispunct(c) ? "sim" : "-");
    }
    return 0;
}

for (int i = 0; texto[i] != '\0'; i++)

Anda pela string até a marca de fim, como em Strings.

unsigned char c = texto[i];

Copia o caractere para um unsigned char (o mesmo cuidado do (unsigned char), escrito de outro jeito: seção 5).

isalpha(c) ? "sim" : "-"

O operador ternário (aula Ternário): se a resposta é diferente de zero, mostra "sim"; se é zero, "-".

$ gcc -std=c23 -Wall -Wextra tabela.c -o tabela
$ ./tabela
char alpha digit alnum space upper lower punct
 'A'  sim     -   sim     -   sim     -     -
 'n'  sim     -   sim     -     -   sim     -
 'a'  sim     -   sim     -     -   sim     -
 ','    -     -     -     -     -     -   sim
 ' '    -     -     -   sim     -     -     -
 '2'    -   sim   sim     -     -     -     -
 '9'    -   sim   sim     -     -     -     -
 ' '    -     -     -   sim     -     -     -
 'a'  sim     -   sim     -     -   sim     -
 'n'  sim     -   sim     -     -   sim     -
 'o'  sim     -   sim     -     -   sim     -
 's'  sim     -   sim     -     -   sim     -
 '!'    -     -     -     -     -     -   sim

Repare: cada caractere do ASCII visível cai em exatamente uma destas três: letra, algarismo ou pontuação. O espaço não é nenhuma das três. E isalnum é só "letra ou algarismo", muito usado para validar nomes de usuário.

#include <ctype.h>
#include <stdio.h>

int main(void) {
    char texto[] = "Ana, 29 anos!";
    printf("char alpha digit space punct\n");
    for (int i = 0; texto[i] != '\0'; i++) {
        unsigned char c = texto[i];
        printf(" '%c'  %3s   %3s   %3s   %3s\n", c,
               isalpha(c) ? "sim" : "-",
               isdigit(c) ? "sim" : "-",
               isspace(c) ? "sim" : "-",
               ispunct(c) ? "sim" : "-");
    }
    return 0;
}

3. Contar e validar

Com uma pergunta por caractere e um laço, dá para contar e para conferir textos inteiros.

Contar letras, algarismos e espaços

#include <ctype.h>
#include <stdio.h>

int main(void) {
    char frase[] = "Pedido 42: 3 cafes e 2 bolos, por favor!";
    int letras = 0, algarismos = 0, espacos = 0, outros = 0;
    for (int i = 0; frase[i] != '\0'; i++) {
        unsigned char c = frase[i];
        if (isalpha(c)) {
            letras++;
        } else if (isdigit(c)) {
            algarismos++;
        } else if (isspace(c)) {
            espacos++;
        } else {
            outros++;
        }
    }
    printf("%s\n", frase);
    printf("letras: %d, algarismos: %d, espaços: %d, outros: %d\n",
           letras, algarismos, espacos, outros);
    return 0;
}

$ gcc -std=c23 -Wall -Wextra contar.c -o contar
$ ./contar
Pedido 42: 3 cafes e 2 bolos, por favor!
letras: 25, algarismos: 4, espaços: 8, outros: 3     « os outros: ':' ',' '!'

O else if (aula else if) garante que cada caractere entra numa conta só. "cafes" está sem acento de propósito: a seção 6 mostra o que o ctype.h faz com o é.

Validar um CEP

Na lojinha, o CEP de entrega tem de ter o formato 01310-100: 9 caracteres, um traço na posição 5 e algarismos no resto.

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

int main(void) {
    char cep[] = "01310-100";
    int ok = strlen(cep) == 9 && cep[5] == '-';
    for (int i = 0; ok && i < 9; i++) {
        if (i != 5 && !isdigit((unsigned char) cep[i])) {
            ok = 0;
        }
    }
    printf("%s: %s\n", cep, ok ? "CEP válido" : "CEP inválido");
    return 0;
}

int ok = strlen(cep) == 9 && cep[5] == '-';

Começa conferindo o tamanho (strlen, aula Funções de String) e o traço. O resultado da comparação é 1 ou 0. Se o tamanho estiver errado, o && nem olha o cep[5] (aula Operadores Lógicos).

ok && i < 9

O laço para assim que algo der errado: não adianta continuar olhando.

i != 5 && !isdigit(…)

"Não é a posição do traço e não é algarismo": então o CEP é inválido. O ! inverte a resposta do isdigit.

$ gcc -std=c23 -Wall -Wextra cep.c -o cep
$ ./cep
01310-100: CEP válido

Troque o CEP por "0131O-100" (com a letra O no lugar do zero) e o programa diz CEP inválido. Para transformar o CEP já validado em número, use strtol (aula Texto ↔ Número).

4. Trocar maiúscula e minúscula: toupper e tolower

toupper ("to upper case", "para maiúscula") recebe um caractere e devolve a versão maiúscula. tolower faz o contrário. O detalhe que importa: se o caractere não é letra, elas devolvem o mesmo caractere, sem mexer.

#include <ctype.h>
#include <stdio.h>

int main(void) {
    char nome[] = "ana maria, 29!";
    for (int i = 0; nome[i] != '\0'; i++) {
        nome[i] = (char) toupper((unsigned char) nome[i]);
    }
    printf("%s\n", nome);
    printf("tolower('Q') = %c\n", tolower('Q'));
    printf("toupper('!') = %c\n", toupper('!'));
    printf("'!' - 32     = %c\n", '!' - 32);
    return 0;
}

toupper((unsigned char) nome[i])

Calcula a maiúscula da letra da posição i. A função não muda a string: ela só devolve um valor novo.

nome[i] = (char) …

Por isso o resultado tem de ser guardado de volta na posição. O toupper devolve um int; o (char) deixa claro que você sabe que ele vai virar char.

toupper('!')

Não é letra: volta o próprio '!'. Os espaços, a vírgula e o 29 do nome também passaram intactos.

'!' - 32

O truque da aula Caracteres, subtrair 32, aplicado a algo que não é letra: 33 − 32 = 1, um caractere de controle invisível.

$ gcc -std=c23 -Wall -Wextra maiusculas.c -o maiusculas
$ ./maiusculas
ANA MARIA, 29!
tolower('Q') = q
toupper('!') = !
'!' - 32     =       « o código 1: invisível no terminal

Esse é o motivo de preferir toupper à conta com 32: a conta só funciona se você tiver certeza de que o caractere é uma letra minúscula. O toupper confere sozinho.

#include <ctype.h>
#include <stdio.h>

int main(void) {
    char nome[] = "ana maria souza";
    for (int i = 0; nome[i] != '\0'; i++) {
        // se nome[i] começa uma palavra, troque por maiúscula

    }
    printf("%s\n", nome);
    return 0;
}

#include <ctype.h>
#include <stdio.h>

int main(void) {
    char nome[] = "ana maria souza";
    for (int i = 0; nome[i] != '\0'; i++) {
        if (i == 0 || nome[i - 1] == ' ') {
            nome[i] = (char) toupper((unsigned char) nome[i]);
        }
    }
    printf("%s\n", nome);
    return 0;
}

O i == 0 || vem primeiro de propósito: quando i é 0, o || já tem a resposta e não calcula nome[i - 1], que seria nome[-1], fora do array (aula Arrays).

Comparar sem ligar para maiúsculas

Um uso muito comum: aceitar S ou s como "sim". Em vez de if (r == 's' || r == 'S'), converta antes: if (tolower((unsigned char) r) == 's'). A aula Validar a Entrada usa esse truque para ler respostas do teclado.

5. Por que (unsigned char)

Até aqui, todo caractere passou por um (unsigned char) antes de entrar numa função do ctype.h. O motivo está na regra da norma do C: essas funções só aceitam um valor que caiba num unsigned char (de 0 a 255) ou o valor especial EOF (o "fim de arquivo" do getchar, que vale −1). Qualquer outro número negativo é comportamento indefinido.

E um char comum pode ser negativo. No Linux de PC (e no editor), ele vai de −128 a 127 (aula Inteiros). As letras do ASCII são todas positivas, mas os bytes de uma letra acentuada passam de 127 e, num char, viram negativos:

#include <ctype.h>
#include <stdio.h>

int main(void) {
    char palavra[] = "é";
    char c = palavra[0];
    printf("como char: %d\n", c);
    printf("como unsigned char: %d\n", (unsigned char) c);
    printf("isalpha(c) = %d\n", isalpha(c));
    printf("toupper(c) = %d\n", toupper(c));
    return 0;
}

$ gcc -std=c23 -Wall -Wextra negativo.c -o negativo     « nenhum aviso
$ ./negativo
como char: -61
como unsigned char: 195
isalpha(c) = 0
toupper(c) = 195

O primeiro byte do é é o 195; num char, ele aparece como −61. O toupper(-61) devolveu 195 no gcc. No editor do guia, o mesmo programa mostrou toupper(c) = -61. Duas bibliotecas, dois resultados, porque a norma não diz o que acontece com −61: é comportamento indefinido (aula Comportamento Indefinido). Na biblioteca do Windows, em modo de depuração, um valor negativo chega a interromper o programa com um alerta.

O conserto é sempre o mesmo: converter para unsigned char antes. Com (unsigned char) c, a função recebe 195, um valor permitido, e todas as bibliotecas dão a mesma resposta. Há dois jeitos de escrever:

6. Acentos não são letras para o ctype.h

A Ana tentou contar as letras de "maçã":

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

int main(void) {
    char palavra[] = "maçã";
    int letras = 0;
    for (int i = 0; palavra[i] != '\0'; i++) {
        unsigned char c = palavra[i];
        printf("byte %d: %3d  isalpha: %s\n", i, c, isalpha(c) ? "sim" : "não");
        if (isalpha(c)) {
            letras++;
        }
    }
    printf("isalpha contou %d letras em \"%s\" (%zu bytes)\n", letras, palavra, strlen(palavra));
    return 0;
}

$ gcc -std=c23 -Wall -Wextra acento.c -o acento
$ ./acento
byte 0: 109  isalpha: sim
byte 1:  97  isalpha: sim
byte 2: 195  isalpha: não     « primeira metade do ç
byte 3: 167  isalpha: não     « segunda metade do ç
byte 4: 195  isalpha: não     « primeira metade do ã
byte 5: 163  isalpha: não     « segunda metade do ã
isalpha contou 2 letras em "maçã" (6 bytes)

"maçã" tem 4 letras, mas 6 bytes: o ç e o ã ocupam 2 bytes cada na codificação UTF-8, a usada pelos arquivos e terminais de hoje. As funções do ctype.h olham um byte por vez, e nenhuma metade de letra é uma letra. O editor dá exatamente a mesma resposta. Na prática:

• o ctype.h é perfeito para o que é ASCII: algarismos, CEP, CPF, códigos de produto, senhas, comandos, respostas "s/n";
• para contar ou converter letras acentuadas de português, ele não serve sozinho. O toupper não transforma ç em Ç, nem ã em Ã.

Como o C lida com acentos de verdade (bytes, strlen que conta "a mais", caracteres largos e setlocale) é o assunto da próxima aula, Acentos e UTF-8.

Formas diferentes: contas com a tabela ou ctype.h?

As duas formas abaixo respondem igual para caracteres ASCII:

Qual usar: o ctype.h. O código fica mais curto, se lê como uma frase, e não há como esquecer um caso (quem lembra do \v no "é espaço?"). A conta manual faz sentido em dois lugares: c - '0' para transformar o algarismo em número (depois de conferir com isdigit), e quando você quer exatamente um intervalo que não é uma categoria pronta, como "é uma letra de a a f?".

Quando dá errado

Referência rápida

Exercícios

Missão final: a senha forte

Maiúsculas: 1
Minúsculas: 6
Algarismos: 4
Senha forte

#include <ctype.h>
#include <stdio.h>

int main(void) {
    char senha[] = "Lojinha2026";
    int maiusculas = 0, minusculas = 0, algarismos = 0, tamanho = 0;
    for (int i = 0; senha[i] != '\0'; i++) {
        unsigned char c = senha[i];
        // conte aqui o tipo do caractere c

        tamanho++;
    }
    printf("Maiúsculas: %d\n", maiusculas);
    printf("Minúsculas: %d\n", minusculas);
    printf("Algarismos: %d\n", algarismos);
    if (tamanho >= 8 && maiusculas > 0 && minusculas > 0 && algarismos > 0) {
        printf("Senha forte\n");
    } else {
        printf("Senha fraca\n");
    }
    return 0;
}

#include <ctype.h>
#include <stdio.h>

int main(void) {
    char senha[] = "Lojinha2026";
    int maiusculas = 0, minusculas = 0, algarismos = 0, tamanho = 0;
    for (int i = 0; senha[i] != '\0'; i++) {
        unsigned char c = senha[i];
        if (isupper(c)) {
            maiusculas++;
        } else if (islower(c)) {
            minusculas++;
        } else if (isdigit(c)) {
            algarismos++;
        }
        tamanho++;
    }
    printf("Maiúsculas: %d\n", maiusculas);
    printf("Minúsculas: %d\n", minusculas);
    printf("Algarismos: %d\n", algarismos);
    if (tamanho >= 8 && maiusculas > 0 && minusculas > 0 && algarismos > 0) {
        printf("Senha forte\n");
    } else {
        printf("Senha fraca\n");
    }
    return 0;
}

A solução testa com if direto (nunca == 1) e usa else if, porque um caractere não pode ser maiúscula e algarismo ao mesmo tempo. Um sistema de verdade também exigiria um símbolo: seria mais um contador com ispunct.

Resumo

• O <ctype.h> traz perguntas prontas sobre um caractere: isdigit, isalpha, isalnum, isspace, isupper, islower, ispunct, isxdigit, isprint, iscntrl…
• A resposta é 0 para "não" e qualquer outro valor para "sim" (2048 no gcc, 1 no editor). Teste com if (isdigit(c)), nunca com == 1.
• toupper e tolower devolvem a letra convertida e deixam o resto igual. Elas não mudam a string: guarde o resultado (s[i] = (char) toupper(…)).
• Sempre (unsigned char) antes de passar um char de uma string: valores negativos são comportamento indefinido, e o resultado muda de uma biblioteca para outra.
• Com um laço, as perguntas contam e validam textos: CEP, senha, códigos.
• O ctype.h olha um byte por vez: os acentos do UTF-8 (2 bytes) não são letras para ele. Para isso, veja Acentos e UTF-8.