C에서 명령 줄 인수를 구문 분석합니까?


98

C에서 두 파일을 한 줄, 한 단어 또는 한 문자 씩 비교할 수있는 프로그램을 작성하려고합니다. 명령 줄 옵션에서 읽을 수 있어야합니다 -l -w -i or --.

  • 옵션이 -l이면 파일을 한 줄씩 비교합니다.
  • 옵션이 -w이면 파일을 단어별로 비교합니다.
  • 옵션이 다음과 같으면 자동으로 다음 인수가 첫 번째 파일 이름이라고 가정합니다.
  • 옵션이 -i이면 대소 문자를 구분하지 않고 비교합니다.
  • 기본적으로 파일을 문자별로 비교합니다.

-w와 -l이 동시에 입력되지 않고 2 개 이하의 파일이있는 한 옵션 입력 횟수는 중요하지 않습니다.

명령 줄 인수를 구문 분석하는 것부터 시작해야 할 위치도 모릅니다. 도와주세요 :(

그래서 이것이 제가 모든 것에 대해 생각 해낸 코드입니다. 아직 오류를 확인하지 않았지만 지나치게 복잡하게 작성하고 있는지 궁금합니다.

/*
 * Functions to compare files.
 */
int compare_line();
int compare_word();
int compare_char();
int case_insens();

/*
 * Program to compare the information in two files and print message saying 
 * whether or not this was successful.
 */
int main(int argc, char* argv[])
{
/*Loop counter*/
  size_t i = 0;

  /*Variables for functions*/
  int caseIns = 0;
  int line = 0;
  int word = 0;

  /*File pointers*/
  FILE *fp1, *fp2;

  /*
   * Read through command-line arguments for options.
   */
  for (i = 1; i < argc; i++) {
    printf("argv[%u] = %s\n", i, argv[i]);
    if (argv[i][0] == '-') {
       if (argv[i][1] == 'i') 
       {
           caseIns = 1;
       }
       if (argv[i][1] == 'l')
       {
           line = 1;
       }
       if (argv[i][1] == 'w')
       {
           word = 1;
       }
       if (argv[i][1] == '-')
       {
           fp1 = argv[i][2];
           fp2 = argv[i][3];
       }
       else 
       {
           printf("Invalid option.");
           return 2;
       }
    } else {
       fp1(argv[i]);
       fp2(argv[i][1]);
    }
  }

  /*
   * Check that files can be opened.
   */
  if(((fp1 = fopen(fp1, "rb")) ==  NULL) || ((fp2 = fopen(fp2, "rb")) == NULL))
  {
      perror("fopen()");
      return 3;
  }
  else{
        if (caseIns == 1)
        {
            if(line == 1 && word == 1)
            {
                printf("That is invalid.");
                return 2;
            }
            if(line == 1 && word == 0)
            {
                if(compare_line(case_insens(fp1, fp2)) == 0)
                        return 0;
            }
            if(line == 0 && word == 1)
            {
                if(compare_word(case_insens(fp1, fp2)) == 0)
                    return 0;
            }
            else
            {
                if(compare_char(case_insens(fp1,fp2)) == 0)
                    return 0;
            }
        }
        else
        {
            if(line == 1 && word == 1)
            {
                printf("That is invalid.");
                return 2;
            }
            if(line == 1 && word == 0)
            {
                if(compare_line(fp1, fp2) == 0)
                    return 0;
            }
            if(line == 0 && word == 1)
            {
                if(compare_word(fp1, fp2) == 0)
                    return 0;
            }
            else
            {
                if(compare_char(fp1, fp2) == 0)
                    return 0;
            }
        }

  }
    return 1;
    if(((fp1 = fclose(fp1)) == NULL) || (((fp2 = fclose(fp2)) == NULL)))
        {
            perror("fclose()");
            return 3;
        }
        else
        {
            fp1 = fclose(fp1);
            fp2 = fclose(fp2);
        }
}

/*
 * Function to compare two files line-by-line.
 */
int compare_line(FILE *fp1, FILE *fp2)
{
    /*Buffer variables to store the lines in the file*/
    char buff1 [LINESIZE];
    char buff2 [LINESIZE];

    /*Check that neither is the end of file*/
    while((!feof(fp1)) && (!feof(fp2)))
    {
        /*Go through files line by line*/
        fgets(buff1, LINESIZE, fp1);
        fgets(buff2, LINESIZE, fp2);
    }
    /*Compare files line by line*/
    if(strcmp(buff1, buff2) == 0)
    {
        printf("Files are equal.\n");
        return 0;
    }
    printf("Files are not equal.\n");
    return 1;
}   

/*
 * Function to compare two files word-by-word.
 */
int compare_word(FILE *fp1, FILE *fp2)
{
    /*File pointers*/
    FILE *fp1, *fp2;

    /*Arrays to store words*/
    char fp1words[LINESIZE];
    char fp2words[LINESIZE];

    if(strtok(fp1, " ") == NULL || strtok(fp2, " ") == NULL)
    {
        printf("File is empty. Cannot compare.\n");
        return 0;
    }
    else
    {
        fp1words = strtok(fp1, " ");
        fp2words = strtok(fp2, " ");

        if(fp1words == fp2words)
        {
            fputs(fp1words);
            fputs(fp2words);
            printf("Files are equal.\n");
            return 0;
        }
    }
    return 1;
}

/*
 * Function to compare two files character by character.
 */
int compare_char(FILE *fp1,FILE *fp2)
{
    /*Variables to store the characters from both files*/
    int c;
    int d;

    /*Buffer variables to store chars*/
    char buff1 [LINESIZE];
    char buff2 [LINESIZE];

    while(((c = fgetc(fp1))!= EOF) && (((d = fgetc(fp2))!=EOF)))
    {
        if(c == d)
        {
            if((fscanf(fp1, "%c", buff1)) == (fscanf(fp2, "%c", buff2)))
            {
                printf("Files have equivalent characters.\n");
                return 1;
                break;
            }
        }

    }
        return 0;
}

/*
 * Function to compare two files in a case-insensitive manner.
 */
int case_insens(FILE *fp1, FILE *fp2, size_t n)
{
    /*Pointers for files.*/
    FILE *fp1, *fp2;

    /*Variable to go through files.*/
    size_t i = 0;

    /*Arrays to store file information.*/
    char fp1store[LINESIZE];
    char fp2store[LINESIZE];

    while(!feof(fp1) && !feof(fp2))
    {
         for(i = 0; i < n; i++)
         {
                fscanf(fp1, "%s", fp1store);
                fscanf(fp2, "%s", fp2store);

                fp1store = tolower(fp1store);
                fp2store = tolower(fp2store);

                return 1;
         }
    }
    return 0;
}

getopt ()를 사용하는 방법을 잘 모르겠습니다 ... 아직 수업에서 배우지 않았습니다.
user1251020

3
그러니 가서 매뉴얼 페이지를 읽어보십시오. 그다지 복잡하지 않으며 매뉴얼 페이지에는 실험 해 볼 수있는 예제가 포함되어있을 것입니다 (그리고 로컬 맨 페이지에없는 경우 웹에서 예제를 찾을 수 있습니다).
Jonathan Leffler 2012 년

1
이것은 높은 수준의 라이브러리입니다 : argparse in c, 매우 사용하기 쉽습니다.
Cofyc


간단한 작업의 경우 라이브러리를 사용하는 대신 직접 굴릴 수 있습니다. 나는 여기에서 시작하기 튜토리얼 쓴 engineeringterminal.com/computer-science/tutorials/...
nalyd88

답변:


188

내가 아는 한 C에서 명령 줄 인수를 구문 분석하는 가장 일반적인 세 ​​가지 방법은 다음과 같습니다.

  • 간단한 인수 구문 분석 작업을 #include <unistd.h>해결할 수있는 Getopt ( POSIX C 라이브러리에서 제공) . bash에 약간 익숙하다면 bash에 내장 된 getopt는 GNU libc의 Getopt를 기반으로합니다.
  • Argp ( #include <argp.h>GNU C 라이브러리에서 제공)는 더 복잡한 작업을 해결 하고 다음과 같은 작업 을 처리 할 수 ​​있습니다 .
    • -?, --help에 대한 도움말 메시지 를 포함하여, 이메일 주소
    • -V, --version대한 버전 정보
    • --usage대한 사용법 메시지
  • 스스로를하는 너무 많은 잘못 또는 낮은 품질을 갈 수있는 한 나는, 다른 사람에게 제공 될 프로그램에 대한 권장하지 않는. 옵션 구문 분석을 중지하기 위해 '-'를 잊어 버리는 일반적인 실수는 하나의 예일뿐입니다.

GNU C 라이브러리 문서에는 Getopt 및 Argp에 대한 몇 가지 멋진 예제가 있습니다.

Getopt 사용 예

#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main(int argc, char *argv[])
{
    bool isCaseInsensitive = false;
    int opt;
    enum { CHARACTER_MODE, WORD_MODE, LINE_MODE } mode = CHARACTER_MODE;

    while ((opt = getopt(argc, argv, "ilw")) != -1) {
        switch (opt) {
        case 'i': isCaseInsensitive = true; break;
        case 'l': mode = LINE_MODE; break;
        case 'w': mode = WORD_MODE; break;
        default:
            fprintf(stderr, "Usage: %s [-ilw] [file...]\n", argv[0]);
            exit(EXIT_FAILURE);
        }
    }

    // Now optind (declared extern int by <unistd.h>) is the index of the first non-option argument.
    // If it is >= argc, there were no non-option arguments.

    // ...
}

Argp 사용 예

#include <argp.h>
#include <stdbool.h>

const char *argp_program_version = "programname programversion";
const char *argp_program_bug_address = "<your@email.address>";
static char doc[] = "Your program description.";
static char args_doc[] = "[FILENAME]...";
static struct argp_option options[] = { 
    { "line", 'l', 0, 0, "Compare lines instead of characters."},
    { "word", 'w', 0, 0, "Compare words instead of characters."},
    { "nocase", 'i', 0, 0, "Compare case insensitive instead of case sensitive."},
    { 0 } 
};

struct arguments {
    enum { CHARACTER_MODE, WORD_MODE, LINE_MODE } mode;
    bool isCaseInsensitive;
};

static error_t parse_opt(int key, char *arg, struct argp_state *state) {
    struct arguments *arguments = state->input;
    switch (key) {
    case 'l': arguments->mode = LINE_MODE; break;
    case 'w': arguments->mode = WORD_MODE; break;
    case 'i': arguments->isCaseInsensitive = true; break;
    case ARGP_KEY_ARG: return 0;
    default: return ARGP_ERR_UNKNOWN;
    }   
    return 0;
}

static struct argp argp = { options, parse_opt, args_doc, doc, 0, 0, 0 };

int main(int argc, char *argv[])
{
    struct arguments arguments;

    arguments.mode = CHARACTER_MODE;
    arguments.isCaseInsensitive = false;

    argp_parse(&argp, argc, argv, 0, 0, &arguments);

    // ...
}

직접 해보기의

#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{   
    bool isCaseInsensitive = false;
    enum { CHARACTER_MODE, WORD_MODE, LINE_MODE } mode = CHARACTER_MODE;
    size_t optind;
    for (optind = 1; optind < argc && argv[optind][0] == '-'; optind++) {
        switch (argv[optind][1]) {
        case 'i': isCaseInsensitive = true; break;
        case 'l': mode = LINE_MODE; break;
        case 'w': mode = WORD_MODE; break;
        default:
            fprintf(stderr, "Usage: %s [-ilw] [file...]\n", argv[0]);
            exit(EXIT_FAILURE);
        }   
    }   

    // *argv points to the remaining non-option arguments.
    // If *argv is NULL, there were no non-option arguments.

    // ...
}   

면책 조항 : 저는 Argp를 처음 사용합니다. 예제에 오류가있을 수 있습니다.


9
정말 철저한 답변, Christian (찬성) 감사합니다. 그러나 Mac 사용자는 argp 접근 방식이 플랫폼 간 호환이되지 않는다는 점을 알고 있어야합니다. 여기서 찾은 것처럼 Argp는 표준화되지 않은 glibc API 확장입니다. gnulib에서 사용할 수 있으므로 프로젝트에 명시 적으로 추가 할 수 있습니다. 그러나 Mac 전용 또는 크로스 플랫폼 개발자가 getopt 접근 방식을 사용하는 것이 더 간단 할 수 있습니다.
thclark

1
do it yourself 버전의 경우 옵션이 나중에 추가 텍스트를 허용하는 것을 좋아하지 않습니다.
Jake

1
@Jake 당신이 맞습니다. 그것을 발견하는 것에 대한 존중. 내가 그것을 썼을 때 그것을 발견했는지 기억이 나지 않습니다. DIY가 너무 쉽게 잘못되어서 수행해서는 안된다는 것은 다시 한 번 완벽한 예입니다. 알려 주셔서 감사합니다. 예를 고칠 수도 있습니다.
기독교 Hujer

18

사용 getopt(), 또는 아마도 getopt_long().

int iflag = 0;
enum { WORD_MODE, LINE_MODE } op_mode = WORD_MODE;  // Default set
int opt;

while ((opt = getopt(argc, argv, "ilw") != -1)
{
    switch (opt)
    {
    case 'i':
        iflag = 1;
        break;
    case 'l':
        op_mode = LINE_MODE;
        break;
    case 'w':
        op_mode = WORD_MODE;
        break;
    default:
        fprintf(stderr, "Usage: %s [-ilw] [file ...]\n", argv[0]);
        exit(EXIT_FAILURE);
    }
}

/* Process file names or stdin */
if (optind >= argc)
    process(stdin, "(standard input)", op_mode);
else
{
    int i;
    for (i = optind; i < argc; i++)
    {
        FILE *fp = fopen(argv[i], "r");
        if (fp == 0)
            fprintf(stderr, "%s: failed to open %s (%d %s)\n",
                    argv[0], argv[i], errno, strerror(errno));
        else
        {
            process(fp, argv[i], op_mode);
            fclose(fp);
        }
    }
 }

포함 할 헤더를 결정해야하며 (필수는 4로 만듭니다) op_mode유형을 작성한 방식 은 함수에 문제가 있음을 의미합니다 process(). 아래에있는 열거 형에 액세스 할 수 없습니다. 열거 형을 함수 외부로 이동하는 것이 가장 좋습니다. 함수에 전달하는 것을 피하기 위해 op_mode외부 연결없이 파일 범위 변수를 만들 수도 있습니다 (멋진 표현 static). 이 코드는 -독자를위한 또 다른 연습 인 표준 입력의 동의어로 처리되지 않습니다 . 참고 getopt()자동으로 돌봐는 --당신을위한 옵션의 끝을 표시합니다.

컴파일러를 지나서 위의 타이핑 버전을 실행 한 적이 없습니다. 실수가있을 수 있습니다.


추가 크레딧을 받으려면 (라이브러리) 함수를 작성하십시오.

int filter(int argc, char **argv, int idx, int (*function)(FILE *fp, const char *fn));

getopt()루프 후 파일 이름 옵션을 처리하기위한 논리를 캡슐화합니다 . -표준 입력으로 처리해야합니다 . 이것을 사용하면 op_mode정적 파일 범위 변수 여야 함을 나타냅니다 . filter()함수 얻어 argc, argv, optind및 처리 기능에 대한 포인터. 모든 파일을 열 수 있고 함수의 모든 호출이 0을보고하면 0 (EXIT_SUCCESS)을 반환하고 그렇지 않으면 1 (또는 EXIT_FAILURE)을 반환해야합니다. 이러한 기능이 있으면 명령 줄 또는 표준 입력에 지정된 파일을 읽는 Unix 스타일 '필터'프로그램 작성이 간단 해집니다.


getopt ()가 첫 번째 파일 이후에 옵션을 허용하지 않는 것이 마음에 들지 않습니다.
Jake

POSIX getopt()는 그렇지 않습니다. GNU getopt()는 기본적으로 수행합니다. 선택해라. 주로 플랫폼간에 신뢰할 수 없기 때문에 파일 이름 동작 이후의 옵션에 관심이 없습니다.
Jonathan Leffler

14

Gengetopt 가 매우 유용하다는 것을 알았 습니다. 간단한 구성 파일로 원하는 옵션을 지정하면 단순히 포함하고 응용 프로그램과 연결하는 .c / .h 쌍이 생성됩니다. 생성 된 코드는 getopt_long을 사용하고 가장 일반적인 종류의 명령 줄 매개 변수를 처리하는 것으로 보이며 많은 시간을 절약 할 수 있습니다.

gengetopt 입력 파일은 다음과 같습니다.

version "0.1"
package "myApp"
purpose "Does something useful."

# Options
option "filename" f "Input filename" string required
option "verbose" v "Increase program verbosity" flag off
option "id" i "Data ID" int required
option "value" r "Data value" multiple(1-) int optional 

코드 생성은 쉽고 뱉어 내고 다음 cmdline.hcmdline.c같습니다.

$ gengetopt --input=myApp.cmdline --include-getopt

생성 된 코드는 쉽게 통합됩니다.

#include <stdio.h>
#include "cmdline.h"

int main(int argc, char ** argv) {
  struct gengetopt_args_info ai;
  if (cmdline_parser(argc, argv, &ai) != 0) {
    exit(1);
  }
  printf("ai.filename_arg: %s\n", ai.filename_arg);
  printf("ai.verbose_flag: %d\n", ai.verbose_flag);
  printf("ai.id_arg: %d\n", ai.id_arg);
  int i;
  for (i = 0; i < ai.value_given; ++i) {
    printf("ai.value_arg[%d]: %d\n", i, ai.value_arg[i]);
  }
}

추가 검사를 수행해야하는 경우 (예 : 플래그가 상호 배타적인지 확인) gengetopt_args_info구조체에 저장된 데이터를 사용하여이 작업을 상당히 쉽게 수행 할 수 있습니다 .


경고를 생성하는 코드를 생성한다는 점을 제외하면 1 ++ :(
cat

안타깝게도, 맞아. 내 cmake 파일에 예외를 넣었습니다.
davidA

아마도 GCC pragma를 사용 하여 해당 파일에 대한 경고를 무시할 것입니다 (내가 알고
cat

소스를 재생성하면 분명히 손실되므로 빌드 프로세스에서 패치로 적용 할 수 있습니다. 솔직히 특정 파일에 대한 경고를 끄는 것이 더 쉽다는 것을 알았습니다.
davidA

아니, #include생성 된 파일 자체가 아니라. 나에게 경고를 끄는 것은 verboten입니다 :-)
cat

6

나는 아무도 James Theiler의 "opt"패키지를 가져 오지 않았다는 것에 매우 놀랐습니다.

http://public.lanl.gov/jt/Software/ 에서 옵트를 찾을 수 있습니다 .

다른 접근 방식보다 훨씬 간단한 방법에 대한 몇 가지 예가 담긴 아첨 게시물이 여기 있습니다.

http://www.decompile.com/not_invented_here/opt/


2
@cat 그 이후로 업데이트가 필요하다고 생각하는 이유는 무엇입니까? 그것은 단순히 소프트웨어에 대한 잘못된 태도입니다.
Joshua Hedges

@JoshuaHedges 내가 직접 프로젝트를 유지하고 싶지 않다면 적극적으로 유지하는 코드에 적극적으로 유지되는 코드를 사용하고 싶습니다. 2006 년부터 많은 프로젝트가 활발하게 유지되고 있지만이 프로젝트는 죽었고 아마도 버그가있을 것입니다. 또한 2 년 전 (거의 정확합니다!) 제가 쓴 글은 아주 오래 전이었습니다 : P
cat

1
opt는 완전하고 컴팩트하기 때문에 적극적으로 유지 관리되지 않습니다. 킥을 위해 방금 다운로드하고 빌드하려고 시도했으며 (gcc-7.3) 라이브러리가 빌드되고 작동한다는 것을 발견했지만 C ++ 테스트는 약간의 작업을 수행 할 수 있습니다. iostream.h는 iostream이되어야하며 네임 스페이스 std를 사용해야합니다. 추가해야합니다. 나는 그것을 James에게 언급 할 것이다. 이는 코드 자체가 아닌 C ++ API 테스트에만 영향을줍니다.
markgalassi

4

Docopt에는 내가 꽤 멋지다고 생각하는 C 구현이 있습니다 : https://github.com/docopt/docopt.c

명령 줄 옵션을 설명하는 맨 페이지 표준 형식에서 docopt는 인수 파서를 추론하고 생성합니다. 이것은 파이썬에서 시작되었습니다. 파이썬 버전은 말 그대로 독 스트링을 구문 분석하고 dict를 반환합니다. C에서이 작업을 수행하려면 조금 더 많은 작업이 필요하지만 사용하기 쉽고 외부 종속성이 없습니다.


3

깔끔한 명령 줄 옵션 구문 분석구성 파일로드 를 포함 하는 훌륭한 범용 C 라이브러리 libUCW 가 있습니다 .

라이브러리는 또한 좋은 문서와 함께 제공되며 다른 유용한 항목 (빠른 IO, 데이터 구조, 할당 자 등)을 포함하지만 별도로 사용할 수 있습니다.

libUCW 옵션 파서 예제 (라이브러리 문서에서)

#include <ucw/lib.h>
#include <ucw/opt.h>

int english;
int sugar;
int verbose;
char *tea_name;

static struct opt_section options = {
  OPT_ITEMS {
    OPT_HELP("A simple tea boiling console."),
    OPT_HELP("Usage: teapot [options] name-of-the-tea"),
    OPT_HELP(""),
    OPT_HELP("Options:"),
    OPT_HELP_OPTION,
    OPT_BOOL('e', "english-style", english, 0, "\tEnglish style (with milk)"),
    OPT_INT('s', "sugar", sugar, OPT_REQUIRED_VALUE, "<spoons>\tAmount of sugar (in teaspoons)"),
    OPT_INC('v', "verbose", verbose, 0, "\tVerbose (the more -v, the more verbose)"),
    OPT_STRING(OPT_POSITIONAL(1), NULL, tea_name, OPT_REQUIRED, ""),
    OPT_END
  }
};

int main(int argc, char **argv)
{
  opt_parse(&options, argv+1);
  return 0;
}

위치 옵션에 버그가 있습니다. 두 개의 OPT_STRING이 있고 하나는 위치가 아닌 경우 구문 분석 할 수 없습니다.
NewBee

2

저는 몇 가지 문제가있는 POpt와 유사한 인수를 구문 분석하는 작은 라이브러리 인 XOpt를 작성했습니다 . GNU 스타일 인수 구문 분석을 사용하며 POpt와 매우 유사한 인터페이스를 가지고 있습니다.

나는 때때로 그것을 큰 성공으로 사용하고 거의 모든 곳에서 작동합니다.


1

가능하다면 나만의 경적을 울리며 내가 작성한 옵션 파싱 라이브러리 인 dropt를 살펴볼 것을 제안하고 싶습니다 .

  • C 라이브러리입니다 (원하는 경우 C ++ 래퍼 포함).
  • 가볍습니다.
  • 확장 가능합니다 (사용자 정의 인수 유형은 쉽게 추가 할 수 있으며 기본 제공 인수 유형과 동일한 기초를 가질 수 있습니다).
  • 의존성이없는 (C 표준 라이브러리 제외) 이식성이 매우 높아야합니다 (표준 C로 작성 됨).
  • 매우 제한적인 라이선스 (zlib / libpng)가 있습니다.

다른 많은 사람들이 제공하지 않는 한 가지 기능은 이전 옵션을 재정의하는 기능입니다. 예를 들어, 쉘 별칭이있는 경우 :

alias bar="foo --flag1 --flag2 --flag3"

사용하고 bar싶지만 --flag1비활성화 된 상태에서 다음을 수행 할 수 있습니다.

bar --flag1=0

0
#include <stdio.h>

int main(int argc, char **argv)
{
    size_t i;
    size_t filename_i = -1;

    for (i = 0; i < argc; i++)
    {
        char const *option =  argv[i];
        if (option[0] == '-')
        {
            printf("I am a flagged option");
            switch (option[1])
            {
                case 'a':
                    /*someting*/
                    break;
                case 'b':
                    break;
                case '-':
                    /* "--" -- the next argument will be a file.*/
                    filename_i = i;
                    i = i + 1;
                    break;
                default:
                    printf("flag not recognised %s", option);
                    break;
            }
        }
        else
        {   
            printf("I am a positional argument");
        }

        /* At this point, if -- was specified, then filename_i contains the index
         into argv that contains the filename. If -- was not specified, then filename_i will be -1*/
     }
  return 0;
}

4
아니; 절대적으로 좋은 방법은 아닙니다 ... 인수 구문 분석 함수 중 하나를 사용하십시오- getopt()또는 getopt_long().
Jonathan Leffler 2012 년

5
이것이 노골적으로 숙제 질문이라는 점을 감안할 때 치트처럼 들립니다. 또한 OP는 문자열의 개념과 일부를 읽는 방법을 이해하는 데 어려움을 겪고 있습니다. 그에게 getopts를 권유하는 것은 실수입니다.
포드

숙제 질문입니다. 나는 문자열이 무엇인지 압니다. 옵션을 여러 번 입력 할 수있을 때 혼란스러워서 파일 이름이 어디에 있는지 실제로 알 수 없기 때문에 명령 줄 인수를 분해하는 방법을 이해하지 못합니다. 내가 너무 생각하고있는 것일까?
user1251020

0

C에서 명령 줄 인수를 구문 분석하기위한 지침 템플릿입니다.

C :> programName -w-fileOne.txt fileTwo.txt

BOOL argLine = FALSE;
BOOL argWord = FALSE;
BOOL argChar = FALSE;
char * fileName1 = NULL;
char * fileName2 = NULL;

int main(int argc, char * argv[]) {
    int i;
    printf("Argument count=%d\n",argc);
    for (i = 0; i < argc; i++) {
        printf("Argument %s\n",argv[i]);
        if (strcmp(argv[i],"-l")==0) {
            argLine = TRUE;
            printf("    argLine=TRUE\n");
        }
        else if (strcmp(argv[i],"-w")==0) {
            argWord = TRUE;
            printf("    argWord=TRUE\n");
        }
        else if (strcmp(argv[i],"-c")==0) {
            argChar = TRUE;
            printf("    argChar=TRUE\n");
        }
        else if (strcmp(argv[i],"--")==0) {
            if (i+1 <= argc) {
                fileName1 = argv[++i];
                printf("    fileName1=%s\n",fileName1);
            }
            if (i+1 <= argc) {
                fileName2 = argv[++i];
                printf("    fileName2=%s\n",fileName2);
            }
        }
    }
    return 0;
}

1
... C에 부울 변수가 있다고 생각하지 않습니다 ...?
user1251020

내 이클립스 / 윈도우 환경에는 BOOL 유형이 있습니다. int 또는 char 유형으로 변경하고 그에 따라 코드를 조정하십시오.
Java42

1
C99에는 _Bool항상 유형 과 및 및 및 모든 매크로 <stdbool.h>를 정의 하는 헤더 가 있습니다 (예외적으로 정의되지 않은 동작을 호출하지 않고 정의되지 않고 재정의 될 수 있지만 해당 라이센스는 '노후화'태그가 지정됨). 따라서 C99 컴파일러가있는 경우 및 . 그렇지 않다면 직접 작성하거나 (어려운 것은 아님) 네이티브 동등한 것을 사용합니다. bool_Booltruefalse__bool_true_false_are_defined<stdbool.h>bool
Jonathan Leffler

1
@Wolfer 내 C 환경에는 BOOL 유형 (typedef int BOOL)과 부울 유형 (typedef unsigned char boolean)이 있으며 유형 bool에 대한 정의가 없습니다. 예제에서는 int 또는 char 유형으로 변경하고 그에 따라 코드를 조정하십시오.
Java42

3
이 접근 방식에 동의하지 않습니다. 라이브러리 함수를 사용하여 옵션을 구문 분석하십시오.
Jonathan Leffler

0
    /*
      Here's a rough one not relying on any libraries.
      Example:
      -wi | -iw //word case insensitive
      -li | -il //line case insensitive
      -- file  //specify the first filename (you could just get the files
      as positional arguments in the else statement instead)
      PS: don't mind the #define's, they're just pasting code :D
    */
    #ifndef OPT_H
    #define OPT_H

    //specify option requires argument
    #define require \
      optarg = opt_pointer + 1; \
      if (*optarg == '\0') \
      { \
        if (++optind == argc) \
          goto opt_err_arg; \
        else \
          optarg = argv[optind]; \
      } \
      opt_pointer = opt_null_terminator;

    //start processing argv
    #define opt \
    int   optind                 = 1; \
    char *opt_pointer            = argv[1]; \
    char *optarg                 = NULL; \
    char  opt_null_terminator[2] = {'\0','\0'}; \
    if (0) \
    { \
      opt_err_arg: \
        fprintf(stderr,"option %c requires argument.\n",*opt_pointer); \
        return 1; \
      opt_err_opt: \
        fprintf(stderr,"option %c is invalid.\n",*opt_pointer); \
        return 1; \
    } \
    for (; optind < argc; opt_pointer = argv[++optind]) \
      if (*opt_pointer++ == '-') \
      { \
        for (;;++opt_pointer) \
          switch (*opt_pointer) \
          {

    //stop processing argv
    #define done \
          default: \
            if (*opt_pointer != '\0') \
              goto opt_err_opt; \
            else \
              goto opt_next; \
            break; \
          } \
        opt_next:; \
      }
    #endif //opt.h

    #include <stdio.h>
    #include "opt.h"
    int
    main (int argc, char **argv)
    {
      #define by_character 0
      #define by_word      1
      #define by_line      2
      int cmp = by_character;
      int case_insensitive = 0;
      opt
      case 'h':
        puts ("HELP!");
        break;
      case 'v':
        puts ("fileCMP Version 1.0");
        break;
      case 'i':
        case_insensitive = 1;
        break;
      case 'w':
        cmp = by_word;
        break;
      case 'l':
        cmp = by_line;
        break;
      case '-':required
        printf("first filename: %s\n", optarg);
        break;
      done
      else printf ("Positional Argument %s\n", argv[optind]);
      return 0;
    }

2
코드를 그냥 던져 버리고 모든 사람이 이해하기를 기대하는 것보다 코드를 설명해야합니다. 복사와 붙여 넣기뿐만 아니라 학습을위한 사이트입니다.
Yokai

0

좋습니다. 긴 이야기의 시작입니다. 짧게 'C에서 명령 줄 구문 분석을 중단했습니다.

/**
* Helper function to parse the command line
* @param argc Argument Counter
* @param argv Argument Vector
* @param prog Program Instance Reference to fill with options
*/
bool parseCommandLine(int argc, char* argv[], DuplicateFileHardLinker* prog) {
  bool pathAdded = false;

  // iterate over all arguments...
  for ( int i = 1; i<argc; i++ ) {

    // is argv a command line option ?
    if ( argv[i][0] == '-' || argv[i][0] == '/' ) {

// ~~~~~~ Optionally Cut that part vvvvvvvvvvvvv for sake of simplicity ~~~~~~~
      // check for longer options
            if ( stricmp( &argv[i][1], "NoFileName"  ) == 0
              ||  strcmp( &argv[i][1], "q1"          ) == 0 ) {

        boNoFileNameLog = true;
      } else if ( strcmp( &argv[i][1], "HowAreYou?"    ) == 0 ) {
          logInfo( "SECRET FOUND: Well - wow I'm glad ya ask me.");
      } else {

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Now here comes the main thing:
//
        // check for one char options
        while ( char option = *++argv[i] ) {

          switch ( option ) {
          case '?':
            // Show program usage

            logInfo(L"Options:");
            logInfo(L"  /q\t>Quite mode");
            logInfo(L"  /v\t>Verbose mode");
            logInfo(L"  /d\t>Debug mode");
            return false;

            // Log options
          case 'q':
            setLogLevel(LOG_ERROR);
            break;

          case 'v':
            setLogLevel(LOG_VERBOSE);
            break;

          case 'd':
            setLogLevel(LOG_DEBUG);
            break;

          default:
            logError(L"'%s' is an illegal command line option!"
                      "  Use /? to see valid options!", option);
            return false;
          } // switch one-char-option
        } //while one-char-options
      }  //else one vs longer options
    } // if isArgAnOption

// 
// ^^^^^^^^^^^^^^^^^^^^^^^^^^^  So that's it! ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
// What follows now is are some usefull extras...
//
    else {


      // the command line options seems to be a path...
      WCHAR tmpPath[MAX_PATH_LENGTH];
      mbstowcs(tmpPath, argv[i], sizeof(tmpPath));

      // check if the path is existing!
      //...

      prog->addPath(tmpPath); //Comment or remove to get a working example
      pathAdded = true;
    }
  }

  // check for parameters
  if ( !pathAdded ) {
    logError("You need to specify at least one folder to process!\n"
             "Use /? to see valid options!");
    return false;
  }

  return true;
}



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

  try {
    // parse the command line
    if ( !parseCommandLine(argc, argv, prog) ) {
      return 1; 
    }

// I know that sample is just to show how the nicely parse commandline Arguments
// So Please excuse more nice useful C-glatter that follows now...
  }
  catch ( LPCWSTR err ) {
    DWORD dwError = GetLastError();
    if ( wcslen(err) > 0 ) {
      if ( dwError != 0 ) {
        logError(dwError, err);
      }
      else {
        logError(err);
      }
    }
    return 2;
  }
}

#define LOG_ERROR               1
#define LOG_INFO                0
#define LOG_VERBOSE             -1
#define LOG_DEBUG               -2

/** Logging Level for the console output */
int logLevel = LOG_INFO;

void logError(LPCWSTR message, ...) {
  va_list argp;
  fwprintf(stderr, L"ERROR: ");
  va_start(argp, message);
  vfwprintf(stderr, message, argp);
  va_end(argp);
  fwprintf(stderr, L"\n");
}


void logInfo(LPCWSTR message, ...) {
  if ( logLevel <= LOG_INFO ) {
    va_list argp;
    va_start(argp, message);
    vwprintf(message, argp);
    va_end(argp);
    wprintf(L"\n");
  }
}

이 버전은 인수 결합도 지원합니다. 따라서 / h / s- > / hs 를 작성하는 대신 에도 작동합니다.

여기에 게시하는 n 번째 사람이되어 죄송합니다.하지만 여기에서 본 모든 독립 실행 형 버전에 만족하지 못했습니다. 글쎄요 lib는 그만 두었습니다. 그래서 libUCW 옵션 파서, Arg 또는 Getopt를 선호합니다. 집에서 만든 것보다 를 합니다.

변경할 수 있습니다.

*++argv[i]-> (++argv*)[0] 더 이상 덜 애매하지만 여전히 애매합니다.

자, 분해 해 보겠습니다. 1. argv [i]-> argv-char 포인터 필드의 i 번째 요소에 액세스합니다.

  1. ++ * ...-> argv 포인터를 한 문자 씩 전달합니다.

  2. ... [0]-> 포인터를 따라 문자를 읽습니다.

  3. ++ (...)-> 대괄호가 있으므로 char 값 자체가 아닌 포인터를 늘릴 것입니다.

그래서 C ##에서 포인터가 '죽었다'는 것이 좋습니다.

당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.