C Language
Kommandoradsargument

Syntax

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

parametrar

Anmärkningar

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

./some_program abba banana mamajam

Skriva ut kommandoradsargumenten

När du har fått argumenten kan du skriva ut dem enligt följande:

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

anteckningar

1. argv parametern kan också definieras som char *argv[] .
2. argv[0] kan innehålla själva programnamnet (beroende på hur programmet kördes). Det första "riktiga" kommandoradsargumentet är vid argv[1] , och detta är anledningen till att slingvariabeln i initialiseras till 1.
3. I utskriften kan du använda *(argv + i) istället för argv[i] - det utvärderar till samma sak, men är mer ordbok.
4. De fyrkantiga parenteserna runt argumentvärdet hjälper till att identifiera början och slutet. Detta kan vara ovärderligt om det finns baksidesämnen, nylinjer, vagnreturer eller andra udda karaktärer i argumentet. Vissa varianter på detta program är ett användbart verktyg för felsökning av skalskript där du behöver förstå vad argumentlistan faktiskt innehåller (även om det finns enkla skalalternativ som nästan är likvärdiga).

Skriv ut argumenten till ett program och konvertera till heltal

Följande kod kommer att skriva ut argumenten till programmet och koden försöker konvertera varje argument till ett nummer (till ett 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;
}

Referenser:

• strtol () returnerar ett felaktigt värde
• Korrekt användning av strtol

Använda GNU getopt-verktyg

Kommandoradsalternativ för applikationer behandlas inte annorlunda än kommandoradsargument från C-språket. Det är bara argument som i en Linux- eller Unix-miljö traditionellt börjar med en streck ( - ).

Med glibc i en Linux- eller Unix-miljö kan du använda getopt-verktygen för att enkelt definiera, validera och analysera kommandoradsalternativ från resten av dina argument.

Dessa verktyg förväntar dig att dina alternativ ska formateras i enlighet med GNU-kodningsstandarder , vilket är en förlängning av vad POSIX anger för formatet för kommandoradsalternativ.

Exemplet nedan visar hantering av kommandoradsalternativ med GNU getopt-verktygen.

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

Det kan sammanställas med gcc :

gcc example.c -o example

Det stöder tre kommandoradsalternativ ( --help , - --file och --msg ). Alla har också en "kort form" ( -h , -f och -m ). Alternativen "fil" och "msg" accepterar båda argument. Om du anger alternativet "msg" krävs dess argument.

Argument för alternativ är formaterade som:

• --option=value (för alternativ i lång form)
• -ovalue eller -o"value" (för kortformat-alternativ)