C Academy · Aula

Lendo caracteres

getchar e putchar.

Lendo caracteres é 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.

Lendo caracteres individuais

C fornece getchar() para ler um caractere por vez da entrada padrão e putchar() para escrever um caractere na saída padrão.

Ambas as funções estão em <stdio.h>.

#include <stdio.h>

int main(void) {
    putchar('H');
    putchar('i');
    putchar('\n');
    return 0;
}

Noções básicas de putchar

putchar(c) escreve o caractere c e retorna o caractere escrito ou EOF em caso de erro.

É a forma mais simples de produzir um único byte.

#include <stdio.h>

int main(void) {
    for (char c = 'A'; c <= 'E'; c++) {
        putchar(c);
    }
    putchar('\n');
    return 0;
}

getchar retorna int

getchar() retorna um int, não um char. Isso é importante porque a função precisa poder retornar EOF, um valor diferente de qualquer caractere real.

Sempre armazene o resultado em um int.

#include <stdio.h>

int main(void) {
    int c = 'A';
    printf("Stored value: %d\n", c);
    return 0;
}

O que é EOF

EOF significa fim do arquivo. getchar() o retorna quando não há mais entrada.

Normalmente, esse valor é -1. Por isso, getchar usa int, evitando que ele seja confundido com o byte 255.

#include <stdio.h>

int main(void) {
    printf("EOF has value %d\n", EOF);
    return 0;
}

O padrão do laço de leitura

O padrão clássico lê caracteres até EOF. Como não há entrada interativa aqui, o laço termina imediatamente, mas este é o formato padrão.

Faça a atribuição dentro da condição.
Compare com EOF.

#include <stdio.h>

int main(void) {
    int c;
    while ((c = getchar()) != EOF) {
        putchar(c);
    }
    printf("Reached end of input\n");
    return 0;
}

Contando caracteres

Uma tarefa comum é contar quantos caracteres foram lidos. Incremente um contador dentro do laço de leitura.

#include <stdio.h>

int main(void) {
    int c;
    long count = 0;
    while ((c = getchar()) != EOF) {
        count++;
    }
    printf("Read %ld characters\n", count);
    return 0;
}

Repetindo em maiúsculas

Você pode transformar cada caractere antes de escrevê-lo. Aqui, todo caractere lido é convertido para maiúscula usando toupper.

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

int main(void) {
    int c;
    while ((c = getchar()) != EOF) {
        putchar(toupper(c));
    }
    return 0;
}

Contando linhas

Contar os caracteres de nova linha informa quantas linhas foram lidas. Teste cada caractere comparando-o com '\n'.

#include <stdio.h>

int main(void) {
    int c;
    int lines = 0;
    while ((c = getchar()) != EOF) {
        if (c == '\n') lines++;
    }
    printf("Lines: %d\n", lines);
    return 0;
}

Devolvendo um char ao fluxo

ungetc(c, stdin) devolve um caractere ao fluxo de entrada, para que a próxima leitura o retorne novamente.

Isso é útil quando você lê um caractere a mais durante uma varredura.

#include <stdio.h>

int main(void) {
    ungetc('X', stdin);
    int c = getchar();
    printf("Got back: %c\n", c);
    return 0;
}

getchar versus scanf

getchar oferece controle preciso no nível dos bytes, enquanto scanf analisa a entrada formatada.

Para processamentos caractere a caractere, como filtros e tokenizadores, getchar é a ferramenta adequada.

#include <stdio.h>

int main(void) {
    int c = '5';
    if (c >= '0' && c <= '9') {
        printf("It is a digit: %c\n", c);
    }
    return 0;
}

Um esqueleto simples de filtro

Os filtros leem da entrada, transformam os dados e escrevem na saída. Este esqueleto remove todos os espaços do fluxo de entrada.

#include <stdio.h>

int main(void) {
    int c;
    while ((c = getchar()) != EOF) {
        if (c != ' ') {
            putchar(c);
        }
    }
    return 0;
}

Verificação rápida

Teste sua compreensão da leitura de caracteres.

Recapitulação

Você aprendeu a ler e escrever caracteres:

getchar() lê um caractere e retorna um int.
putchar(c) escreve um caractere.
EOF indica o fim da entrada; use o laço while ((c = getchar()) != EOF).
ungetc pode devolver um caractere ao fluxo.

Perguntas Frequentes

A aula “Lendo caracteres” é grátis?

Sim — o texto completo de “Lendo caracteres” é 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 “Lendo caracteres”?

getchar e putchar. 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 “Lendo caracteres”?

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

← Voltar para C Academy