在 C 中解析命令行参数 [英] Parsing command-line arguments in C

问题描述

我正在尝试编写一个程序，该程序可以在 C 中逐行、逐字或逐字符地比较两个文件.它必须能够读取命令行选项 -l、-w、-i 或 --...

I'm trying to write a program that can compare two files line by line, word by word, or character by character in C. It has to be able to read in command line options -l, -w, -i or --...

• 如果选项是-l，它会逐行比较文件.
• 如果选项是-w，它会逐字比较文件.
• 如果选项是 --，它会自动假定下一个参数是第一个文件名.
• 如果选项是 -i，它会以不区分大小写的方式比较它们.
• 默认逐字符比较文件.

• if the option is -l, it compares the files line by line.
• if the option is -w, it compares the files word by word.
• if the option is --, it automatically assumes that the next argument is the first filename.
• if the option is -i, it compares them in a case insensitive manner.
• defaults to comparing the files character by character.

只要-w 和-l 不是同时输入并且没有更多选项，输入多少次应该无关紧要或少于两个文件.

It's not supposed to matter how many times the options are input as long as -w and -l aren't inputted at the same time and there are no more or less than two files.

我什至不知道从哪里开始解析命令行参数.

I don't even know where to begin with parsing the command line arguments.

所以这是我为所有事情想出的代码.我还没有对它进行错误检查，但我写的东西是否过于复杂?

So this is the code that I came up with for everything. I haven't error checked it quite yet, but am I writing things in an overcomplicated manner?

/*
 * 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
", 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.
");
        return 0;
    }
    printf("Files are not equal.
");
    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.
");
        return 0;
    }
    else
    {
        fp1words = strtok(fp1, " ");
        fp2words = strtok(fp2, " ");

        if(fp1words == fp2words)
        {
            fputs(fp1words);
            fputs(fp2words);
            printf("Files are equal.
");
            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.
");
                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;
}

推荐答案

据我所知，在 C 中解析命令行参数的三种最流行的方法是:

To my knowledge, the three most popular ways how to parse command line arguments in C are:

• Getopt(#include 来自 POSIX C 库)，可以解决简单的参数解析任务.如果您对 bash 有点熟悉，那么 bash 的内置 getopt 是基于 GNU libc 的 Getopt.
• Argp(#include 来自 GNU C 库)，它可以解决更复杂的任务并照顾的东西，例如:
  • -?, --help 用于帮助信息，包括电子邮件地址
  • -V, --version 用于版本信息
  • --usage 用于使用信息
  • Getopt (#include <unistd.h> from the POSIX C Library), which can solve simple argument parsing tasks. If you're a bit familiar with bash, the getopt built-in of bash is based on Getopt from the GNU libc.
  • Argp (#include <argp.h> from the GNU C Library), which can solve more complex tasks and takes care of stuff like, for example:
    • -?, --help for help message, including email address
    • -V, --version for version information
    • --usage for usage message

    GNU C 库文档有一些很好的 Getopt 和 Argp 示例.

    The GNU C Library documentation has some nice examples for Getopt and Argp.

    • http://www.gnu.org/software/libc/手册/html_node/Getopt.html
    • http://www.gnu.org/software/libc/手册/html_node/Argp.html

    #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...]
    ", 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 = "<[e-mail]>";
    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...]
    ", argv[0]);
                exit(EXIT_FAILURE);
            }   
        }
        argv += optind;
    
        // *argv points to the remaining non-option arguments.
        // If *argv is NULL, there were no non-option arguments.
    
        // ...
    }   
    

    免责声明:我是 Argp 的新手，该示例可能包含错误.

    Disclaimer: I am new to Argp, the example might contain errors.

    这篇关于在 C 中解析命令行参数的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！