/*
      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;
    }

Насколько мне известно, три наиболее популярных способа анализа аргументов командной строки в C:

• Getopt (#include <unistd.h> из библиотеки POSIX C), который может решить простой анализ аргументов . Если вы немного знакомы с bash, getopt встроенный bash основан на Getopt из GNU libc.
• Argp (#include <argp.h> из библиотеки GNU C), который может решить больше сложных задач и позаботится о таких вещах, как, например: -?, --help для справочного сообщения , включая адрес электронной почты -V, --version для информации о версии --usage для сообщения об использовании
• Выполнение этого самостоятельно, что я не рекомендую для программ, которые будут предоставлены кто-то другой, так как слишком много, что может пойти не так или некачественно. Популярная ошибка забывания о «-», чтобы прекратить парсинг параметров - это всего лишь один пример.

В документации библиотеки GNU C есть несколько хороших примеров для Getopt и Argp.

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

Пример использования 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, пример может содержать ошибки.

Docopt имеет реализацию C, которую я считал довольно приятной: https://github.com/docopt/docopt.c

Из стандартного формата в формате man, параметры командной строки, docopt infers и создает парсер аргументов. Это началось в python; версия python буквально просто анализирует docstring и возвращает dict. Для этого в C требуется немного больше работы, но он чист в использовании и не имеет внешних зависимостей.

Если я могу использовать собственный рожок, я также хотел бы предложить взглянуть на библиотеку разбора параметров, которую я написал: dropt .

• Это библиотека C (при необходимости, с помощью C ++-оболочки).
• Легкий.
• Он расширяемый (типы настраиваемых аргументов могут быть легко добавлены и иметь равную основу со встроенным аргументом типы.)
• Он должен быть очень портативным (он написан в стандарте C) без зависимостей (кроме стандартной библиотеки C).
• Он имеет очень неограниченную лицензию (zlib / libpng).

Одна из функций, которую он предлагает, что многие другие не поддерживают переопределение предыдущих параметров. Например, если у вас есть псевдоним оболочки:

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

, и вы хотите использовать bar, но с отключенным --flag1, это позволяет:

bar --flag1=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;
}

Используйте 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);
        }
    }
 }

Обратите внимание, что вам нужно определить, какие заголовки должны включать (I сделайте 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). Наличие такой функции упрощает запись программ «фильтра» в стиле Unix, которые читают файлы, указанные в командной строке или стандартном вводе.

Я очень удивлен, что никто не поднял пакет «opt» Джеймса Тейлера.

Вы можете выбрать http://public.lanl.gov/jt/Software/

и лестное сообщение с некоторыми примерами того, как это намного проще, чем другие подходы:

http://www.decompile.com/not_invented_here/ выбрать /

Я нашел 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_info.