C Language
Kommandozeilenargumente

Syntax

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

Parameter

Bemerkungen

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

./some_program abba banana mamajam

Befehlszeilenargumente drucken

Nachdem Sie die Argumente erhalten haben, können Sie sie wie folgt drucken:

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

Anmerkungen

1. Der Parameter argv kann auch als char *argv[] .
2. argv[0] kann den Programmnamen selbst enthalten (abhängig davon, wie das Programm ausgeführt wurde). Das erste "echte" Befehlszeilenargument lautet argv[1] . Dies ist der Grund, warum die Schleifenvariable i auf 1 initialisiert wird.
3. In der print-Anweisung können Sie *(argv + i) anstelle von argv[i] - es wird dasselbe ausgewertet, ist jedoch ausführlicher.
4. Die eckigen Klammern um den Argumentwert helfen, den Anfang und das Ende zu identifizieren. Dies kann von unschätzbarem Wert sein, wenn das Argument nachstehende Leerzeichen, Zeilenumbrüche, Zeilenumbrüche oder andere Sonderzeichen enthält. Einige Varianten dieses Programms sind ein nützliches Werkzeug zum Debuggen von Shell-Skripts, bei denen Sie wissen müssen, was die Argumentliste tatsächlich enthält (obwohl es einfache Shell-Alternativen gibt, die fast gleichwertig sind).

Drucken Sie die Argumente an ein Programm und konvertieren Sie sie in Ganzzahlwerte

Der folgende Code gibt die Argumente an das Programm aus und der Code versucht, jedes Argument in eine Zahl (in eine long Zahl) umzuwandeln:

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

VERWEISE:

• strtol () gibt einen falschen Wert zurück
• Richtige Verwendung von strtol

Verwenden von GNU-getopt-Werkzeugen

Befehlszeilenoptionen für Anwendungen werden von der C-Sprache nicht anders als Befehlszeilenargumente behandelt. Sie sind nur Argumente, die in einer Linux- oder Unix-Umgebung traditionell mit einem Bindestrich ( - ) beginnen.

Mit glibc in einer Linux- oder Unix-Umgebung können Sie die getopt-Tools verwenden, um auf einfache Weise Befehlszeilenoptionen für die restlichen Argumente zu definieren, zu überprüfen und zu analysieren.

Diese Tools erwarten, dass Ihre Optionen gemäß den GNU-Codierungsstandards formatiert sind. Dies ist eine Erweiterung der von POSIX für das Format der Befehlszeilenoptionen festgelegten Optionen.

Das folgende Beispiel veranschaulicht die Handhabung von Befehlszeilenoptionen mit den GNU-getopt-Werkzeugen.

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

Es kann mit gcc kompiliert werden:

gcc example.c -o example

Es unterstützt drei Befehlszeilenoptionen ( --help , --file und --msg ). Alle haben auch eine "Kurzform" ( -h , -f und -m ). Die Optionen "Datei" und "msg" akzeptieren beide Argumente. Wenn Sie die Option "msg" angeben, ist dessen Argument erforderlich.

Argumente für Optionen werden wie folgt formatiert:

• --option=value (für Langformoptionen)
• -ovalue oder -o"value" (für Kurzformoptionen)