C Language
Opdrachtregelargumenten

Syntaxis

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

parameters

Opmerkingen

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

./some_program abba banana mamajam

De opdrachtregelargumenten afdrukken

Na ontvangst van de argumenten kunt u ze als volgt afdrukken:

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

Notes

1. De parameter argv kan ook worden gedefinieerd als char *argv[] .
2. argv[0] kan de programmanaam zelf bevatten (afhankelijk van hoe het programma werd uitgevoerd). Het eerste "echte" opdrachtregelargument staat op argv[1] , en dit is de reden waarom de lusvariabele i wordt geïnitialiseerd op 1.
3. In de print-instructie kunt u *(argv + i) plaats van argv[i] - het evalueert hetzelfde, maar is uitgebreider.
4. De vierkante haken rond de argumentwaarde helpen bij het identificeren van het begin en einde. Dit kan van onschatbare waarde zijn als er achterliggende spaties, nieuwe regels, regelterugloop of andere vreemde tekens in het argument voorkomen. Een variant op dit programma is een handig hulpmiddel voor het debuggen van shell-scripts waarbij u moet weten wat de argumentlijst eigenlijk bevat (hoewel er eenvoudige shell-alternatieven zijn die bijna equivalent zijn).

Druk de argumenten af naar een programma en converteer naar gehele getallen

De volgende code drukt de argumenten naar het programma af en de code probeert elk argument in een getal om te zetten (naar een long nummer):

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

Referenties:

• strtol () retourneert een onjuiste waarde
• Correct gebruik van strtol

Getoptools van GNU gebruiken

Opdrachtregelopties voor toepassingen worden door de C-taal niet anders behandeld dan opdrachtregelargumenten. Het zijn slechts argumenten die in een Linux- of Unix-omgeving traditioneel beginnen met een streepje ( - ).

Met glibc in een Linux- of Unix-omgeving kunt u de getopt-tools gebruiken om eenvoudig opdrachtregelopties te definiëren, valideren en ontleden uit de rest van uw argumenten.

Deze tools verwachten dat uw opties worden opgemaakt volgens de GNU-coderingsstandaarden , een uitbreiding van wat POSIX opgeeft voor het formaat van opdrachtregelopties.

Het onderstaande voorbeeld laat zien hoe opdrachtregelopties kunnen worden verwerkt met de GNU getopt-tools.

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

Het kan worden gecompileerd met gcc :

gcc example.c -o example

Het ondersteunt drie opdrachtregelopties ( --help , --file en --msg ). Alle hebben ook een "korte vorm" ( -h , -f en -m ). De opties "bestand" en "msg" accepteren beide argumenten. Als u de optie "msg" opgeeft, is het argument vereist.

Argumenten voor opties worden opgemaakt als:

• --option=value (voor lange- --option=value )
• -ovalue of -o"value" (voor korte formulieropties)