การแยกวิเคราะห์อาร์กิวเมนต์บรรทัดคำสั่งใน C?


103

ฉันกำลังพยายามเขียนโปรแกรมที่สามารถเปรียบเทียบไฟล์สองไฟล์ทีละบรรทัดทีละคำหรืออักขระทีละตัวใน 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

4
ดังนั้นไปอ่านหน้าคู่มือสำหรับมัน มันไม่ซับซ้อนมากและหน้าคู่มืออาจมีตัวอย่างให้คุณทดลองใช้ (และหากเพจคนในพื้นที่ของคุณไม่มีคุณสามารถหาตัวอย่างได้จากเว็บ)
Jonathan Leffler

1
นี่คือไลบรารีระดับสูง: argparseใน c ใช้งานง่ายมาก
Cofyc


สำหรับเนื้อหาง่ายๆคุณสามารถม้วนของคุณเองแทนที่จะใช้ห้องสมุด ฉันเขียนบทช่วยสอนการเริ่มต้นที่นี่engineeringterminal.com/computer-science/tutorials/…
nalyd88

คำตอบ:


196

ตามความรู้ของฉันสามวิธียอดนิยมในการแยกวิเคราะห์อาร์กิวเมนต์บรรทัดคำสั่งใน C คือ:

  • getopt ( #include <unistd.h>จาก POSIX C Library) ซึ่งสามารถแก้ปัญหาการโต้แย้งการแยกง่ายงาน หากคุณคุ้นเคยกับ bash เล็กน้อย getopt ในตัวของ bash จะขึ้นอยู่กับ Getopt จาก GNU libc
  • Argp ( #include <argp.h>จาก GNU C Library) ซึ่งสามารถแก้ปัญหางานที่ซับซ้อนมากขึ้นและดูแลสิ่งต่างๆเช่น:
    • -?, --helpสำหรับข้อความช่วยเหลือรวมถึงที่อยู่อีเมล
    • -V, --versionสำหรับข้อมูลเกี่ยวกับรุ่น
    • --usageสำหรับข้อความการใช้งาน
  • ทำด้วยตัวเองซึ่งฉันไม่แนะนำสำหรับโปรแกรมที่จะมอบให้กับคนอื่นเนื่องจากมีมากเกินไปที่อาจผิดพลาดหรือคุณภาพต่ำลง ข้อผิดพลาดยอดนิยมในการลืม "-" เพื่อหยุดการแยกวิเคราะห์ตัวเลือกเป็นเพียงตัวอย่างเดียว

เอกสาร GNU C Library มีตัวอย่างที่ดีสำหรับ 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
สำหรับเวอร์ชันที่ทำด้วยตัวเองฉันไม่ชอบที่ตัวเลือกจะอนุญาตให้มีข้อความพิเศษในภายหลังเช่น -wzzz แยกวิเคราะห์เหมือนกับ -w และตัวเลือกต้องมาก่อนอาร์กิวเมนต์ของไฟล์
Jake

1
@ เจคคุณพูดถูก เคารพในการระบุสิ่งนั้น ฉันจำไม่ได้ว่าฉันเห็นสิ่งนั้นเมื่อฉันเขียนมันหรือไม่ เป็นตัวอย่างที่สมบูรณ์แบบอีกครั้งที่ DIY ทำผิดพลาดได้ง่ายและไม่ควรทำ ขอบคุณที่บอกฉันอาจแก้ไขตัวอย่าง
Christian 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 (EXIT_SUCCESS) หากสามารถเปิดไฟล์ทั้งหมดและการเรียกใช้ฟังก์ชันทั้งหมดที่รายงาน 0 มิฉะนั้น 1 (หรือ EXIT_FAILURE) การมีฟังก์ชันดังกล่าวช่วยลดความยุ่งยากในการเขียนโปรแกรม 'ตัวกรอง' สไตล์ยูนิกซ์ที่อ่านไฟล์ที่ระบุในบรรทัดคำสั่งหรืออินพุตมาตรฐาน


ฉันไม่ชอบที่ getopt () ไม่อนุญาตตัวเลือกหลังจากไฟล์แรก
Jake

POSIX getopt()ไม่; GNU getopt()ทำโดยค่าเริ่มต้น เลือกของคุณ ฉันไม่สนใจตัวเลือกหลังจากพฤติกรรมชื่อไฟล์ส่วนใหญ่เป็นเพราะมันไม่น่าเชื่อถือในทุกแพลตฟอร์ม
Jonathan Leffler

15

ฉันพบว่า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.hและcmdline.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_infostruct


1 ++ ยกเว้นว่าจะสร้างรหัสที่สร้างคำเตือน :(
cat

ใช่น่าเสียดาย ฉันใส่ข้อยกเว้นในไฟล์ cmake ของฉัน
davidA

ฉันอาจจะใช้GCC pragmas เพื่อละเว้นคำเตือนสำหรับไฟล์นั้น (ฉันรู้แย่มาก)
cat

โปรดทราบว่าคุณจะสูญเสียมันอย่างชัดเจนหากคุณสร้างซอร์สขึ้นมาใหม่ดังนั้นคุณอาจต้องการใช้เป็นแพตช์ในกระบวนการสร้างของคุณ ตรงไปตรงมาฉันพบว่าการปิดคำเตือนในไฟล์เฉพาะเหล่านั้นง่ายขึ้น
davidA

ไม่ฉันหมายถึงการวาง pragmas ไว้รอบ ๆ#includeไม่ใช่ในไฟล์ที่สร้างขึ้นเอง สำหรับฉันการปิดคำเตือนคือverboten :-)
cat

6

ฉันประหลาดใจมากที่ไม่มีใครนำแพ็คเกจ "opt" ของ James Theiler มาให้

คุณสามารถเลือกได้ที่http://public.lanl.gov/jt/Software/

และโพสต์ที่ประจบสอพลอพร้อมตัวอย่างว่ามันง่ายกว่าวิธีอื่น ๆ มากแค่ไหนอยู่ที่นี่:

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


2
@cat อะไรที่ทำให้คุณคิดว่าจำเป็นต้องมีการอัปเดตตั้งแต่นั้นมา? นั่นเป็นเพียงทัศนคติที่ไม่ถูกต้องเกี่ยวกับซอฟต์แวร์
Joshua Hedges

@JoshuaHedges เว้นแต่ว่าฉันต้องการรักษาโปรเจ็กต์ด้วยตัวเองฉันต้องการใช้รหัสที่ดูแลอย่างแข็งขันในรหัสที่ดูแลอย่างแข็งขันของฉัน มีโครงการมากมายจากปี 2549 ที่ได้รับการดูแลอย่างต่อเนื่อง แต่โครงการนี้เสียชีวิตและอาจมีข้อบกพร่องนอกจากนี้เมื่อ 2 ปีก่อน (เกือบเป๊ะ!) เมื่อนานมาแล้วที่ฉันเขียนว่า: P
cat

1
opt ไม่ได้รับการบำรุงรักษาอย่างแข็งขันเนื่องจากสมบูรณ์และกะทัดรัด สำหรับการเตะฉันเพิ่งดาวน์โหลดและลองสร้าง (gcc-7.3) และพบว่าไลบรารีสร้างและใช้งานได้ แต่การทดสอบ C ++ สามารถทำได้กับงานเล็กน้อย iostream.h ควรกลายเป็น iostream และใช้ namespace std; ควรจะเพิ่ม ฉันจะพูดถึงเจมส์ สิ่งนี้มีผลกับการทดสอบ C ++ API เท่านั้นไม่ใช่ตัวโค้ด
markgalassi

5

Docopt มีการใช้งาน C ที่ฉันคิดว่าค่อนข้างดี: https://github.com/docopt/docopt.c

จากรูปแบบมาตรฐานของ man-page ที่อธิบายตัวเลือกบรรทัดคำสั่ง docopt จะอนุมานและสร้างตัวแยกวิเคราะห์อาร์กิวเมนต์ สิ่งนี้เริ่มต้นใน python; เวอร์ชัน python เพียงแค่แยกวิเคราะห์ docstring และส่งคืนคำสั่ง การทำเช่นนี้ใน C ต้องใช้เวลาทำงานมากกว่าเล็กน้อย แต่ใช้งานได้สะอาดและไม่มีการพึ่งพาภายนอก


3

มีดีวัตถุประสงค์ทั่วไป C ห้องสมุดlibUCWซึ่งรวมถึงเรียบร้อยบรรทัดคำสั่งตัวเลือกการแยกและไฟล์ config โหลด

ไลบรารียังมาพร้อมกับเอกสารที่ดีและมีสิ่งที่มีประโยชน์อื่น ๆ (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 ++ wrapper ถ้าต้องการ)
  • มีน้ำหนักเบา
  • สามารถขยายได้ (ประเภทอาร์กิวเมนต์ที่กำหนดเองสามารถเพิ่มได้อย่างง่ายดายและมีฐานรากเท่ากับประเภทอาร์กิวเมนต์ในตัว)
  • ควรพกพาได้มาก (เขียนด้วยมาตรฐาน 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

5
ฟังดูเหมือนโกงเนื่องจากว่านี่เป็นคำถามการบ้านอย่างโจ่งแจ้ง นอกจากนี้ OP ยังมีปัญหาในการทำความเข้าใจกับแนวคิดของสตริงและวิธีการอ่านบางส่วนของสตริง การหลบหนีจากเขาถือเป็นความผิดพลาด
Pod

เป็นคำถามการบ้าน ฉันรู้ว่าสตริงคืออะไร ฉันไม่เข้าใจวิธีการแยกอาร์กิวเมนต์บรรทัดคำสั่งเพราะดูเหมือนว่าฉันจะสับสนเมื่อคุณสามารถป้อนตัวเลือกได้หลายครั้งดังนั้นคุณจึงไม่สามารถเข้าใจได้ว่าชื่อไฟล์อยู่ที่ไหน บางทีฉันอาจคิดมากไป?
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

สภาพแวดล้อม eclipse / windows ของฉันมีประเภท BOOL เพียงแค่เปลี่ยนเป็นพิมพ์ int หรือ char และปรับรหัสตามนั้น
Java42

1
C99 มีประเภท_Boolตลอดเวลาและส่วนหัว<stdbool.h>ที่กำหนดboolเป็น_Boolและtrueและfalseและ__bool_true_false_are_definedมาโครทั้งหมด (ซึ่งโดยเฉพาะอย่างยิ่งสามารถกำหนดและนิยามใหม่ได้โดยไม่ต้องเรียกใช้พฤติกรรมที่ไม่ได้กำหนดอย่างไรก็ตามใบอนุญาตนั้นติดแท็ก 'ล้าสมัย') ดังนั้นหากคุณมีคอมไพเลอร์ C99 คุณสามารถใช้<stdbool.h>และbool. หากไม่เป็นเช่นนั้นคุณอาจเขียนด้วยตัวคุณเอง (ไม่ใช่เรื่องยาก) หรือคุณใช้ค่าเทียบเท่าดั้งเดิม
Jonathan Leffler

1
@Wolfer สภาพแวดล้อม C ของฉันมีประเภท BOOL (เป็น typedef int BOOL) และพิมพ์บูลีน (เป็นบูลีนถ่านที่ไม่ได้ลงชื่อ typedef) และไม่มีคำจำกัดความสำหรับประเภทบูล ในตัวอย่างเพียงแค่เปลี่ยนเป็นพิมพ์ 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

เอาล่ะนั่นคือจุดเริ่มต้นของเรื่องยาว - ทำสั้น ๆ 'bort แยกวิเคราะห์บรรทัดคำสั่งใน 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ก็ใช้ได้เช่นกัน

ขออภัยที่เป็นคนโพสต์ที่นี่ - อย่างไรก็ตามฉันไม่ค่อยพอใจกับเวอร์ชันสแตนด์อะโลนทั้งหมดที่ฉันเห็นที่นี่ พวก lib ก็เลิกดี ดังนั้นฉันจึงชอบตัวแยกวิเคราะห์ตัวเลือกlibUCW , ArgหรือGetoptมากกว่าตัวทำที่บ้าน

โปรดทราบว่าคุณอาจเปลี่ยนแปลง:

*++argv[i]-> (++argv*)[0] ลึกลับน้อยลงอีกต่อไป แต่ยังคงเป็นความลับ

เอาล่ะมาแยกย่อย: 1. argv [i] -> เข้าถึงองค์ประกอบ i-th ในฟิลด์ตัวชี้ argv-char

  1. ++ * ... -> จะส่งต่อตัวชี้ argv ทีละตัวอักษร

  2. ... [0] -> จะตามตัวชี้อ่านอักขระ

  3. ++ (... ) -> วงเล็บอยู่ที่นั่นดังนั้นเราจะเพิ่มตัวชี้ไม่ใช่ค่าถ่านเอง

ดีมากที่ใน C ## คำชี้ 'เสียชีวิต' - คำชี้แนะอยู่นาน !!!

โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.