C Language
Arguments de ligne de commande

Syntaxe

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

Paramètres

Remarques

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

./some_program abba banana mamajam

Impression des arguments de la ligne de commande

Après avoir reçu les arguments, vous pouvez les imprimer comme suit:

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

Remarques

1. Le paramètre argv peut également être défini comme étant char *argv[] .
2. argv[0] peut contenir le nom du programme lui-même (en fonction de l'exécution du programme). Le premier argument "réel" de la ligne de commande est à argv[1] , et c'est la raison pour laquelle la variable de boucle i est initialisée à 1.
3. Dans l'instruction print, vous pouvez utiliser *(argv + i) au lieu de argv[i] - il évalue la même chose, mais est plus verbeux.
4. Les crochets autour de la valeur de l'argument aident à identifier le début et la fin. Cela peut être inestimable s'il y a des blancs, des nouvelles lignes, des retours chariot ou d'autres caractères inhabituels dans l'argument. Certaines variantes de ce programme sont un outil utile pour déboguer des scripts shell dans lesquels vous devez comprendre ce que contient la liste d'arguments (bien qu'il existe des alternatives de shell simples, presque équivalentes).

Imprimer les arguments dans un programme et convertir en valeurs entières

Le code suivant imprimera les arguments au programme et le code tentera de convertir chaque argument en un nombre (à 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;
}

LES RÉFÉRENCES:

• strtol () renvoie une valeur incorrecte
• Utilisation correcte de strtol

Utiliser les outils GNU getopt

Les options de ligne de commande pour les applications ne sont pas traitées différemment des arguments de ligne de commande par le langage C. Ce ne sont que des arguments qui, dans un environnement Linux ou Unix, commencent traditionnellement par un tiret ( - ).

Avec glibc dans un environnement Linux ou Unix, vous pouvez utiliser les outils getopt pour définir, valider et analyser facilement les options de ligne de commande du reste de vos arguments.

Ces outils s'attendent à ce que vos options soient formatées conformément aux normes de codage GNU , qui sont une extension de ce que POSIX spécifie pour le format des options de ligne de commande.

L'exemple ci-dessous illustre la gestion des options de ligne de commande avec les outils GNU getopt.

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

Il peut être compilé avec gcc :

gcc example.c -o example

Il prend en charge trois options de ligne de commande ( --help , --file et --msg ). Tous ont aussi une "forme courte" ( -h , -f et -m ). Les options "fichier" et "msg" acceptent toutes deux des arguments. Si vous spécifiez l'option "msg", son argument est requis.

Les arguments pour les options sont formatés comme suit:

• --option=value (pour les options de formulaire long)
• -ovalue ou -o"value" (pour les options -ovalue )