C Language
명령 줄 인수

통사론

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

매개 변수

비고

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

./some_program abba banana mamajam

명령 행 인수 인쇄하기

인수를받은 후 다음과 같이 인쇄 할 수 있습니다.

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

노트

1. argv 매개 변수는 char *argv[] 로 정의 할 수도 있습니다.
2. argv[0] 에는 프로그램 이름 자체 가 포함될 수 있습니다 (프로그램 실행 방법에 따라 다름). 첫 번째 "실제"명령 행 인수는 argv[1] 있으며, 이것이 루프 변수 i 가 1로 초기화되는 이유입니다.
3. print 문에서 argv[i] 대신 *(argv + i) 를 사용할 수 있습니다. 동일한 결과를 얻지 만 좀 더 자세한 정보입니다.
4. 인수 값 주위의 대괄호는 시작과 끝을 식별하는 데 도움이됩니다. 인수에 후미 공백, 개행 문자, 캐리지 리턴 또는 다른 괴짜 문자가있는 경우이 값은 매우 중요합니다. 이 프로그램의 일부 변형은 인수 목록에 실제로 포함되어있는 것을 이해해야하는 곳에서 쉘 스크립트를 디버깅하는 데 유용한 도구입니다 (거의 동일한 간단한 쉘 대안이 있지만).

인수를 프로그램에 인쇄하고 정수 값으로 변환하십시오.

다음 코드는 프로그램에 인수를 인쇄하고 코드는 각 인수를 숫자로 변환하려고 시도합니다 ( 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;
}

참고 문헌 :

• strtol ()은 잘못된 값을 반환합니다.
• strtol의 올바른 사용법

GNU getopt 도구 사용하기

응용 프로그램의 명령 행 옵션은 C 언어의 명령 행 인수와 다르게 처리되지 않습니다. 그것들은 리눅스 나 유닉스 환경에서 전통적으로 대시 ( - )로 시작하는 논증 일뿐입니다.

Linux 또는 Unix 환경에서 glibc를 사용하면 getopt 도구 를 사용하여 나머지 인수에서 명령 행 옵션을 쉽게 정의, 유효성 검증 및 구문 분석 할 수 있습니다.

이 도구들은 여러분의 옵션이 GNU 코딩 표준 에 따라 포맷 될 것을 기대하는데, 이는 POSIX가 명령 행 옵션의 형식에 대해 지정한 것을 확장 한 것입니다.

아래 예제는 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;
}

gcc 로 컴파일 할 수 있습니다 :

gcc example.c -o example

세 가지 명령 행 옵션 ( --help , --file 및 --msg )을 지원합니다. 모두 "짧은 형식"도 있습니다 ( -h , -f 및 -m ). "file"및 "msg"옵션은 모두 인수를 허용합니다. "msg"옵션을 지정하면 인수가 필요합니다.

옵션의 인수는 다음과 같이 형식화됩니다.

• --option=value (긴 형식 옵션의 경우)
• -ovalue 또는 -o"value" (짧은 형식 옵션의 경우)