0Pricing
C Academy · Lección

Ejemplos prácticos

Una función de logging

Ejemplos prácticos es una lección gratuita de C Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C Academy incluye 4 lecciones en total.

Una función de registro

Un registrador es un uso perfecto de los argumentos variádicos en el mundo real. Queremos poder llamar a log_msg("user %s scored %d", name, score) igual que a printf.

Esta lección crea una pequeña y útil utilidad 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;
}

Añadir un nivel de gravedad

Los registradores reales etiquetan los mensajes con un nivel como INFO o ERROR. Añada un parámetro fijo antes de la cadena de formato para indicar el nivel.

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

Añadir marcas de tiempo a los mensajes

Puede enriquecer cada línea con contexto adicional antes de reenviar el formato. Aquí anteponemos un contador ficticio como sustituto de una marca de tiempo.

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

Registrar en stderr

Los errores y diagnósticos suelen enviarse a stderr. Use vfprintf(stderr, fmt, args) para que la salida del registro no se mezcle con la salida normal del 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

Un umbral de verbosidad permite silenciar los mensajes de baja prioridad. Compare el nivel del mensaje con un mínimo configurado antes de imprimirlo.

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

Construir una cadena de mensaje

A veces querrá tener el texto con formato en un búfer en lugar de imprimirlo. Use vsnprintf para generarlo y después decida qué hacer con él.

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

Una función variádica para calcular el máximo

Los argumentos variádicos también sirven para funciones auxiliares matemáticas. Aquí tiene una función que devuelve el mayor de varios enteros mediante un parámetro de conteo.

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

Concatenar cadenas

Mediante un centinela NULL, podemos unir cualquier cantidad de cadenas en un solo búfer.

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

Contar enteros variádicos

Un contador basado en un centinela muestra la flexibilidad de este patrón. Contamos valores hasta encontrar un 0 de terminación.

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

Envolverlo en una macro

Un recurso habitual es una macro que rellena automáticamente el nivel para que los llamadores escriban menos. La macro reenvía la llamada a la función 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;
}

Poner en uso el registrador

Aquí tiene un minirregistrador completo que combina un nivel y un contador de marcas de tiempo, listo para incorporarlo a un 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;
}

Comprobación rápida

Compruebe su comprensión del diseño de registros variádicos.

Resumen

Ha creado herramientas variádicas prácticas:

  • Un registrador que reenvía su formato a vprintf/vfprintf.
  • Añadió niveles, contadores, salida a stderr y filtrado condicional.
  • Usó vsnprintf para capturar mensajes en búferes.
  • Vio auxiliares basados en centineles y un envoltorio de conveniencia mediante una macro.

Preguntas frecuentes

¿La lección «Ejemplos prácticos» es gratis?

Sí — el texto completo de «Ejemplos prácticos» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C Academy, actualiza a CoddyKit PRO. El curso de C Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Ejemplos prácticos»?

Una función de logging Practicas C Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar C Academy?

No se requiere experiencia previa. C Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.

¿Cuánto tiempo toma la lección «Ejemplos prácticos»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de C Academy?

Sí. Cada lección de C Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Macros de stdarg
  2. Escritura de funciones similares a printf
  3. Consideraciones sobre la seguridad de tipos
  4. Ejemplos prácticos
← Volver a C Academy