0Pricing
C Academy · Lección

Análisis de opciones

Gestione flags

Análisis de opciones es una lección gratuita de C Academy en CoddyKit. Esta es la lección 2 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.

Opciones frente a argumentos posicionales

Los argumentos de la línea de comandos son de dos tipos. Los argumentos posicionales son valores como nombres de archivo. Las opciones (también llamadas flags) comienzan con un guion, como -v o --help.

En esta lección se muestra cómo detectar y gestionar flags manualmente.

#include <stdio.h>

int main(int argc, char *argv[]) {
    for (int i = 1; i < argc; i++) {
        if (argv[i][0] == '-')
            printf("option: %s\n", argv[i]);
        else
            printf("value:  %s\n", argv[i]);
    }
    return 0;
}

Detectar un flag

Para comprobar un flag específico, compare cada argumento con strcmp.

Aquí establecemos un booleano cuando encontramos -v para activar el modo detallado.

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

int main(int argc, char *argv[]) {
    int verbose = 0;
    for (int i = 1; i < argc; i++) {
        if (strcmp(argv[i], "-v") == 0)
            verbose = 1;
    }
    printf("verbose = %d\n", verbose);
    return 0;
}

Admitir opciones largas

Muchas herramientas aceptan tanto una forma corta (-h) como una forma larga (--help).

Compruebe ambas formas con dos comparaciones unidas mediante ||.

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

int main(int argc, char *argv[]) {
    for (int i = 1; i < argc; i++) {
        if (strcmp(argv[i], "-h") == 0 ||
            strcmp(argv[i], "--help") == 0) {
            printf("Usage: prog [options]\n");
            return 0;
        }
    }
    printf("No help requested\n");
    return 0;
}

Opciones que reciben un valor

Algunos flags necesitan un argumento, como -o output.txt. Cuando encuentra uno de estos flags, el elemento siguiente de argv es su valor.

Avance el índice del bucle y compruebe que no haya superado el final.

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

int main(int argc, char *argv[]) {
    const char *output = "default.txt";
    for (int i = 1; i < argc; i++) {
        if (strcmp(argv[i], "-o") == 0 && i + 1 < argc) {
            output = argv[++i];
        }
    }
    printf("Output file: %s\n", output);
    return 0;
}

Gestionar la ausencia de un valor

Si -o es el último argumento, no hay ningún valor después de él. Leer argv[i+1] quedaría fuera de los límites.

Compruebe siempre i + 1 < argc antes de consumir el siguiente token e informe de un error en caso contrario.

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

int main(int argc, char *argv[]) {
    for (int i = 1; i < argc; i++) {
        if (strcmp(argv[i], "-n") == 0) {
            if (i + 1 >= argc) {
                printf("Error: -n needs a value\n");
                return 1;
            }
            printf("n = %s\n", argv[++i]);
        }
    }
    return 0;
}

Combinar flags booleanos y valores

Un analizador realista controla varios flags a la vez: algunos booleanos y otros con valores. Utilice variables independientes para cada configuración.

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

int main(int argc, char *argv[]) {
    int verbose = 0;
    const char *name = "world";
    for (int i = 1; i < argc; i++) {
        if (strcmp(argv[i], "-v") == 0) verbose = 1;
        else if (strcmp(argv[i], "-name") == 0 && i+1 < argc) name = argv[++i];
    }
    if (verbose) printf("verbose mode\n");
    printf("Hello, %s\n", name);
    return 0;
}

Reconocer el final de las opciones

Por convención, un -- independiente marca el final de las opciones. Todo lo que aparece después se trata como un argumento posicional, aunque comience con un guion.

Esto permite a los usuarios pasar nombres de archivo que comienzan con -.

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

int main(int argc, char *argv[]) {
    int opts_done = 0;
    for (int i = 1; i < argc; i++) {
        if (!opts_done && strcmp(argv[i], "--") == 0) {
            opts_done = 1;
            continue;
        }
        printf("%s: %s\n", opts_done ? "value" : "token", argv[i]);
    }
    return 0;
}

Recopilar argumentos posicionales

A menudo necesitará flags y una lista de archivos. Omita las opciones reconocidas y guarde el resto como argumentos posicionales.

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

int main(int argc, char *argv[]) {
    for (int i = 1; i < argc; i++) {
        if (argv[i][0] == '-') continue;
        printf("file: %s\n", argv[i]);
    }
    return 0;
}

Gestionar opciones desconocidas

Una herramienta fácil de usar informa de los flags desconocidos en lugar de ignorarlos silenciosamente. Compruebe cada argumento con sus opciones conocidas y muestre una advertencia en caso contrario.

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

int main(int argc, char *argv[]) {
    for (int i = 1; i < argc; i++) {
        if (argv[i][0] != '-') continue;
        if (strcmp(argv[i], "-v") != 0)
            printf("Unknown option: %s\n", argv[i]);
    }
    return 0;
}

Convertir valores de opciones

Los valores de las opciones llegan como cadenas. Convierta los valores numéricos con strtol, que también informa de los errores de análisis mediante un puntero al final.

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

int main(int argc, char *argv[]) {
    int count = 1;
    for (int i = 1; i < argc; i++) {
        if (strcmp(argv[i], "-c") == 0 && i+1 < argc)
            count = (int) strtol(argv[++i], NULL, 10);
    }
    printf("count = %d\n", count);
    return 0;
}

Por qué ayuda un analizador real

El análisis manual funciona, pero se vuelve complicado con flags cortos combinados (-vf), la sintaxis con = (--name=foo) y las reglas de orden.

La función estándar getopt, que se explica a continuación, gestiona estas convenciones por usted.

#include <stdio.h>

int main(int argc, char *argv[]) {
    printf("Parsed %d tokens manually\n", argc - 1);
    return 0;
}

Comprobación rápida

Compruebe su comprensión de los problemas del análisis de opciones.

Resumen

Ha aprendido a analizar opciones manualmente:

  • Los flags comienzan con -; compárelos con strcmp.
  • Admita formas cortas y largas con ||.
  • Las opciones que reciben valores consumen el token siguiente; protéjalas con i + 1 < argc.
  • -- termina el análisis de opciones; informe de los flags desconocidos y convierta los valores numéricos con strtol.

Preguntas frecuentes

¿La lección «Análisis de opciones» es gratis?

Sí — el texto completo de «Análisis de opciones» 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 «Análisis de opciones»?

Gestione flags 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 2 de 4.

¿Cuánto tiempo toma la lección «Análisis de opciones»?

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. argc y argv
  2. Análisis de opciones
  3. getopt
  4. Creación de una herramienta CLI
← Volver a C Academy