C Language
Argumentos de línea de comando

Sintaxis

• int main (int argc, char * argv [])

Parámetros

Observaciones

int main(int argc, char *argv[])

./some_program abba banana mamajam

Imprimiendo los argumentos de la línea de comando

Después de recibir los argumentos, puede imprimirlos de la siguiente manera:

int main(int argc, char **argv)
{
    for (int i = 1; i < argc; i++)
    {
        printf("Argument %d: [%s]\n", i, argv[i]); 
    }
}

Notas

1. El parámetro argv también se puede definir como char *argv[] .
2. argv[0] puede contener el nombre del programa (dependiendo de cómo se ejecutó el programa). El primer argumento de línea de comando "real" está en argv[1] , y esta es la razón por la que la variable de bucle i se inicializa en 1.
3. En la declaración de impresión, puede usar *(argv + i) lugar de argv[i] : se evalúa para la misma cosa, pero es más detallado.
4. Los corchetes alrededor del valor del argumento ayudan a identificar el inicio y el final. Esto puede ser invaluable si hay espacios en blanco, nuevas líneas, retornos de carro u otros caracteres extraños en el argumento. Alguna variante de este programa es una herramienta útil para depurar scripts de shell donde necesita comprender lo que realmente contiene la lista de argumentos (aunque existen alternativas de shell simples que son casi equivalentes).

Imprima los argumentos a un programa y conviértalos a valores enteros.

El siguiente código imprimirá los argumentos en el programa, y ​​el código intentará convertir cada argumento en un número (a un long ):

#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <limits.h>

int main(int argc, char* argv[]) {

    for (int i = 1; i < argc; i++) {
        printf("Argument %d is: %s\n", i, argv[i]);

        errno = 0;
        char *p;
        long argument_numValue = strtol(argv[i], &p, 10);

        if (p == argv[i]) {
            fprintf(stderr, "Argument %d is not a number.\n", i);
        }
        else if ((argument_numValue == LONG_MIN || argument_numValue == LONG_MAX) && errno == ERANGE) {
            fprintf(stderr, "Argument %d is out of range.\n", i);
        }
        else {
            printf("Argument %d is a number, and the value is: %ld\n",
                   i, argument_numValue);
        }
    }
    return 0;
}

Referencias

• strtol () devuelve un valor incorrecto
• Uso correcto de strtol

Usando las herramientas getopt de GNU

Las opciones de línea de comandos para aplicaciones no se tratan de manera diferente de los argumentos de línea de comandos por el lenguaje C. Son solo argumentos que, en un entorno Linux o Unix, tradicionalmente comienzan con un guión ( - ).

Con glibc en un entorno Linux o Unix, puede usar las herramientas getopt para definir, validar y analizar fácilmente las opciones de línea de comandos del resto de sus argumentos.

Estas herramientas esperan que sus opciones sean formateadas de acuerdo con los Estándares de Codificación GNU , que es una extensión de lo que POSIX especifica para el formato de las opciones de la línea de comando.

El siguiente ejemplo muestra cómo manejar las opciones de línea de comandos con las herramientas getopt de GNU.

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

/* print a description of all supported options */
void usage (FILE *fp, const char *path)
{
    /* take only the last portion of the path */
    const char *basename = strrchr(path, '/');
    basename = basename ? basename + 1 : path;

    fprintf (fp, "usage: %s [OPTION]\n", basename);
    fprintf (fp, "  -h, --help\t\t"
                 "Print this help and exit.\n");
    fprintf (fp, "  -f, --file[=FILENAME]\t"
                 "Write all output to a file (defaults to out.txt).\n");
    fprintf (fp, "  -m, --msg=STRING\t"
                 "Output a particular message rather than 'Hello world'.\n");
}

/* parse command-line options and print message */
int main(int argc, char *argv[])
{
    /* for code brevity this example just uses fixed buffer sizes for strings */
    char filename[256] = { 0 };
    char message[256] = "Hello world";
    FILE *fp;
    int help_flag = 0;
    int opt;

    /* table of all supported options in their long form.
     * fields: name, has_arg, flag, val
     * `has_arg` specifies whether the associated long-form option can (or, in
     * some cases, must) have an argument. the valid values for `has_arg` are
     * `no_argument`, `optional_argument`, and `required_argument`.
     * if `flag` points to a variable, then the variable will be given a value
     * of `val` when the associated long-form option is present at the command
     * line.
     * if `flag` is NULL, then `val` is returned by `getopt_long` (see below)
     * when the associated long-form option is found amongst the command-line
     * arguments.
     */
    struct option longopts[] = {
        { "help", no_argument, &help_flag, 1 },
        { "file", optional_argument, NULL, 'f' },
        { "msg", required_argument, NULL, 'm' },
        { 0 }
    };

    /* infinite loop, to be broken when we are done parsing options */
    while (1) {
        /* getopt_long supports GNU-style full-word "long" options in addition
         * to the single-character "short" options which are supported by
         * getopt.
         * the third argument is a collection of supported short-form options.
         * these do not necessarily have to correlate to the long-form options.
         * one colon after an option indicates that it has an argument, two
         * indicates that the argument is optional. order is unimportant.
         */
        opt = getopt_long (argc, argv, "hf::m:", longopts, 0);

        if (opt == -1) {
            /* a return value of -1 indicates that there are no more options */
            break;
        }

        switch (opt) {
        case 'h':
            /* the help_flag and value are specified in the longopts table,
             * which means that when the --help option is specified (in its long
             * form), the help_flag variable will be automatically set.
             * however, the parser for short-form options does not support the
             * automatic setting of flags, so we still need this code to set the
             * help_flag manually when the -h option is specified.
             */
            help_flag = 1;
            break;
        case 'f':
            /* optarg is a global variable in getopt.h. it contains the argument
             * for this option. it is null if there was no argument.
             */
            printf ("outarg: '%s'\n", optarg);
            strncpy (filename, optarg ? optarg : "out.txt", sizeof (filename));
            /* strncpy does not fully guarantee null-termination */
            filename[sizeof (filename) - 1] = '\0';
            break;
        case 'm':
            /* since the argument for this option is required, getopt guarantees
             * that aptarg is non-null.
             */
            strncpy (message, optarg, sizeof (message));
            message[sizeof (message) - 1] = '\0';
            break;
        case '?':
            /* a return value of '?' indicates that an option was malformed.
             * this could mean that an unrecognized option was given, or that an
             * option which requires an argument did not include an argument.
             */
            usage (stderr, argv[0]);
            return 1;
        default:
            break;
        }
    }

    if (help_flag) {
        usage (stdout, argv[0]);
        return 0;
    }

    if (filename[0]) {
        fp = fopen (filename, "w");
    } else {
        fp = stdout;
    }

    if (!fp) {
        fprintf(stderr, "Failed to open file.\n");
        return 1;
    }

    fprintf (fp, "%s\n", message);

    fclose (fp);
    return 0;
}

Se puede compilar con gcc :

gcc example.c -o example

Admite tres opciones de línea de comandos ( --help , --file y --msg ). Todos tienen también una "forma corta" ( -h , -f y -m ). Las opciones "archivo" y "msg" aceptan argumentos. Si especifica la opción "msg", se requiere su argumento.

Los argumentos para las opciones se formatean como:

• --option=value (para opciones de formato largo)
• -ovalue o -o"value" (para opciones de formato corto)