C Language
Argumenty wiersza polecenia

Składnia

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

Parametry

Uwagi

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

./some_program abba banana mamajam

Drukowanie argumentów wiersza poleceń

Po otrzymaniu argumentów możesz wydrukować je w następujący sposób:

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

Notatki

1. Parametr argv można również zdefiniować jako char *argv[] .
2. argv[0] może zawierać samą nazwę programu (w zależności od sposobu wykonania programu). Pierwszy „prawdziwy” argument wiersza poleceń znajduje się w argv[1] , i to jest powód, dla którego zmienna pętli i jest inicjowana na 1.
3. W instrukcji print możesz użyć *(argv + i) zamiast argv[i] - ocenia to samo, ale jest bardziej szczegółowe.
4. Nawiasy kwadratowe wokół wartości argumentu pomagają zidentyfikować początek i koniec. Może to być nieocenione, jeśli w argumencie występują końcowe spacje, znaki nowej linii, znaki powrotu karetki lub inne nieparzyste znaki. Niektóre warianty tego programu są przydatnym narzędziem do debugowania skryptów powłoki, w których należy zrozumieć, co faktycznie zawiera lista argumentów (chociaż istnieją proste alternatywy powłoki, które są prawie równoważne).

Wydrukuj argumenty do programu i przekonwertuj na wartości całkowite

Poniższy kod wypisze argumenty do programu, a kod spróbuje przekonwertować każdy argument na liczbę (na 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;
}

BIBLIOGRAFIA:

• Funkcja strtol () zwraca niepoprawną wartość
• Prawidłowe użycie strtol

Korzystanie z narzędzi GNU getopt

Opcje wiersza polecenia dla aplikacji nie są traktowane inaczej niż argumenty wiersza polecenia w języku C. Są to tylko argumenty, które w środowisku Linux lub Unix tradycyjnie zaczynają się od myślnika ( - ).

Dzięki glibc w środowisku Linux lub Unix możesz używać narzędzi getopt do łatwego definiowania, sprawdzania poprawności i analizowania opcji wiersza poleceń na podstawie pozostałych argumentów.

Narzędzia te oczekują, że opcje zostaną sformatowane zgodnie ze standardami kodowania GNU , które są rozszerzeniem tego, co POSIX określa dla formatu opcji wiersza poleceń.

Poniższy przykład pokazuje obsługę opcji wiersza poleceń za pomocą narzędzi 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;
}

Można go skompilować z gcc :

gcc example.c -o example

Obsługuje trzy opcje wiersza poleceń ( --help , --file i --msg ). Wszystkie mają również „krótką formę” ( -h , -f i -m ). Zarówno opcje „plik”, jak i „msg” akceptują argumenty. Jeśli określisz opcję „msg”, jej argument jest wymagany.

Argumenty opcji są sformatowane jako:

• --option=value (dla opcji długich formularzy)
• -ovalue lub -o"value" (dla opcji skróconych)