C Academy · Aula

Exemplos práticos

Uma função de logging.

Exemplos práticos é uma aula grátis de C Academy no CoddyKit. Esta é a aula 4 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.

Uma função de registro

Uma função de registro é um uso prático perfeito de argumentos variádicos. Queremos chamar log_msg("user %s scored %d", name, score), assim como printf.

Nesta lição, você criará uma pequena e útil ferramenta de registro.

#include <stdio.h>
#include <stdarg.h>

void log_msg(const char *fmt, ...) {
    va_list a; va_start(a, fmt);
    vprintf(fmt, a);
    va_end(a);
    printf("\n");
}

int main(void) {
    log_msg("user %s scored %d", "Ann", 90);
    return 0;
}

Adicionando um nível de severidade

Funções de registro reais classificam as mensagens com um nível, como INFO ou ERROR. Adicione um parâmetro fixo antes da cadeia de formato para representar o nível.

#include <stdio.h>
#include <stdarg.h>

void logf(const char *level, const char *fmt, ...) {
    printf("[%s] ", level);
    va_list a; va_start(a, fmt);
    vprintf(fmt, a);
    va_end(a);
    printf("\n");
}

int main(void) {
    logf("INFO", "started with %d workers", 4);
    return 0;
}

Adicionando marcas de tempo às mensagens

Você pode enriquecer cada linha com contexto adicional antes de encaminhar o formato. Aqui, adicionamos um contador fictício como substituto de uma marca de tempo.

#include <stdio.h>
#include <stdarg.h>

static int line_no = 0;

void logf(const char *fmt, ...) {
    printf("#%d ", ++line_no);
    va_list a; va_start(a, fmt);
    vprintf(fmt, a);
    va_end(a);
    printf("\n");
}

int main(void) {
    logf("first %s", "event");
    logf("value %d", 7);
    return 0;
}

Registrando em stderr

Erros e informações de diagnóstico geralmente são enviados para stderr. Use vfprintf(stderr, fmt, args) para que a saída do registro não se misture à saída normal do programa.

#include <stdio.h>
#include <stdarg.h>

void err(const char *fmt, ...) {
    fprintf(stderr, "ERROR: ");
    va_list a; va_start(a, fmt);
    vfprintf(stderr, fmt, a);
    va_end(a);
    fprintf(stderr, "\n");
}

int main(void) {
    err("failed to open %s", "data.txt");
    return 0;
}

Registro condicional

Um limite de verbosidade permite silenciar mensagens de baixa prioridade. Compare o nível da mensagem com um mínimo configurado antes de imprimi-la.

#include <stdio.h>
#include <stdarg.h>

static int min_level = 2;

void logf(int level, const char *fmt, ...) {
    if (level < min_level) return;
    va_list a; va_start(a, fmt);
    vprintf(fmt, a);
    va_end(a);
    printf("\n");
}

int main(void) {
    logf(1, "debug hidden");
    logf(3, "important %d", 42);
    return 0;
}

Criando uma cadeia de mensagem

Às vezes, você quer o texto formatado em um buffer, e não impresso. Use vsnprintf para gerá-lo e, depois, decida o que fazer.

#include <stdio.h>
#include <stdarg.h>

void capture(const char *fmt, ...) {
    char buf[128];
    va_list a; va_start(a, fmt);
    vsnprintf(buf, sizeof(buf), fmt, a);
    va_end(a);
    printf("captured: %s\n", buf);
}

int main(void) {
    capture("id=%d name=%s", 5, "box");
    return 0;
}

Uma função variádica de máximo

Argumentos variádicos também funcionam para auxiliares matemáticos. Esta é uma função que retorna o maior de vários inteiros usando um parâmetro de contagem.

#include <stdio.h>
#include <stdarg.h>

int max_of(int count, ...) {
    va_list a; va_start(a, count);
    int best = va_arg(a, int);
    for (int i = 1; i < count; i++) {
        int v = va_arg(a, int);
        if (v > best) best = v;
    }
    va_end(a);
    return best;
}

int main(void) {
    printf("%d\n", max_of(4, 3, 9, 2, 7));
    return 0;
}

Concatenando cadeias de caracteres

Usando uma sentinela NULL, podemos unir qualquer quantidade de cadeias de caracteres em um único buffer.

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

void join(char *out, const char *first, ...) {
    out[0] = '\0';
    va_list a; va_start(a, first);
    const char *s = first;
    while (s) { strcat(out, s); s = va_arg(a, const char *); }
    va_end(a);
}

int main(void) {
    char buf[64];
    join(buf, "a", "b", "c", (char *)NULL);
    printf("%s\n", buf);
    return 0;
}

Contando inteiros variádicos

Um contador baseado em sentinela mostra como esse padrão é flexível. Contamos os valores até encontrar um 0 de término.

#include <stdio.h>
#include <stdarg.h>

int count_until_zero(int first, ...) {
    va_list a; va_start(a, first);
    int n = 0, v = first;
    while (v != 0) { n++; v = va_arg(a, int); }
    va_end(a);
    return n;
}

int main(void) {
    printf("%d\n", count_until_zero(5, 6, 7, 0));
    return 0;
}

Encapsulando como uma macro

Um truque comum é usar uma macro que preenche o nível automaticamente, para que os chamadores escrevam menos. A macro encaminha a chamada para a função variádica real.

#include <stdio.h>
#include <stdarg.h>

void real_log(const char *lvl, const char *fmt, ...) {
    printf("[%s] ", lvl);
    va_list a; va_start(a, fmt);
    vprintf(fmt, a);
    va_end(a);
    printf("\n");
}

#define LOG_INFO(...) real_log("INFO", __VA_ARGS__)

int main(void) {
    LOG_INFO("ready in %d ms", 50);
    return 0;
}

Colocando a função de registro em uso

Aqui está uma pequena função de registro completa, que combina um nível e um contador de marcas de tempo, pronta para ser incorporada a um programa.

#include <stdio.h>
#include <stdarg.h>

static int seq = 0;

void mylog(const char *lvl, const char *fmt, ...) {
    printf("%04d [%s] ", ++seq, lvl);
    va_list a; va_start(a, fmt);
    vprintf(fmt, a);
    va_end(a);
    printf("\n");
}

int main(void) {
    mylog("INFO", "boot ok");
    mylog("WARN", "low memory: %d MB", 64);
    return 0;
}

Verificação rápida

Teste sua compreensão do projeto de registro variádico.

Recapitulação

Você criou ferramentas variádicas práticas:

Uma função de registro que encaminha seu formato para vprintf/vfprintf.
Adicionou níveis, contadores, saída em stderr e filtragem condicional.
Usou vsnprintf para capturar mensagens em buffers.
Conheceu auxiliares baseados em sentinelas e uma macro de encapsulamento conveniente.

Perguntas Frequentes

A aula “Exemplos práticos” é grátis?

Sim — o texto completo de “Exemplos práticos” é 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 “Exemplos práticos”?

Uma função de logging. 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 4 de 4.

Quanto tempo leva a aula “Exemplos práticos”?

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