我正在尝试编写一个程序，可以逐行，逐字或逐字符地比较两个文件。它必须能够读入命令行选项-l -w -i or -- ...
只要-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;
}
答案 0 :(得分：146)
据我所知，如何在C中解析命令行参数的三种最流行的方法是：
#include <unistd.h>），它可以解决简单参数解析任务。如果你对bash有点熟悉，那么bash的getopt内置是基于GNU libc的Getopt。#include <argp.h>），它可以解决更多复杂任务并负责处理类似的事情，例如：
-?，--help 帮助消息，包括电子邮件地址 -V，--version 版本信息 --usage 用法消息 GNU C Library文档有一些很好的Getopt和Argp示例。
#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.
// ...
}
#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的新手，该示例可能包含错误。
答案 1 :(得分：15)
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）。具有这样的功能简化了编写Unix风格的“过滤器”程序，这些程序读取命令行或标准输入上指定的文件。
答案 2 :(得分：9)
我发现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结构中存储的数据轻松完成此操作。
答案 3 :(得分：4)
我很惊讶没有人提起詹姆斯·塞勒＆＃34;选择＆＃34;封装
您可以在http://public.lanl.gov/jt/Software/
找到选择这是一个讨人喜欢的帖子，里面有一些如何比其他方法简单得多的例子：
答案 4 :(得分：3)
Docopt有一个我认为非常好的C实现：https://github.com/docopt/docopt.c
从描述命令行选项的手册页标准化格式，docopt推断并创建参数解析器。这是从python开始的; python版本只是解析文档字符串并返回一个字典。要在C中执行此操作需要更多的工作，但它使用起来很干净并且没有外部依赖性。
答案 5 :(得分：2)
有一个很棒的通用C库libUCW，其中包含整齐的command-line option parsing和config file loading。
该库还附带了很好的文档，并包含一些其他有用的东西（快速IO，数据结构，分配器......），但这可以单独使用。
#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;
}
答案 6 :(得分：1)
我写了一个很小的库来解析类似于POpt的论点，我有几个问题，称为XOpt。使用GNU样式的参数解析，并且具有与POpt非常相似的接口。
我不时地使用它取得了巨大的成功，它几乎可以在任何地方使用。
答案 7 :(得分：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;
}
答案 8 :(得分：0)
用于解析C中命令行参数的指令模板。
C：＆gt; 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;
}
答案 9 :(得分：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;
}
答案 10 :(得分：0)
如果可能的话，我自己也会发出自己的号角，我还想建议看一下我写过的解析库的选项：dropt。
它提供的一个功能是许多其他功能不能覆盖之前的选项。例如，如果您有一个shell别名：
alias bar="foo --flag1 --flag2 --flag3"
并且您希望使用bar但禁用--flag1，则可以执行以下操作：
bar --flag1=0
答案 11 :(得分：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个元素
++ * ...->将通过一个字符转发argv指针
... [0]->将跟随指针读取字符
++（...）->括号在那里，因此我们将增加指针而不是char值本身。
太好了 在C ##中，指针“死了”-指针万岁！！！
答案 12 :(得分：0)
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int is_arg(int ac, char **argv, char *arg) {
if (ac < 2) {
return 0;
}
for(int x=1; x < ac; x++) {
if (0 == strcmp(argv[x], arg)) {
return x; // return position of arg
}
}
return 0; // arg not present
}
int main (int argc, char *argv[]) {
int z = 0;
if (argc < 2) {
printf("no args present, aborting.\n");
exit(1);
}
(z=is_arg(argc, argv, "bar")) ? printf("TRUE %d\n", z) : printf("FALSE\n");
(z=is_arg(argc, argv, "one bar")) ? printf("TRUE %d\n", z) : printf("FALSE\n");
(z=is_arg(argc, argv, "foo")) ? printf("TRUE %d\n", z) : printf("FALSE\n");
/* testing:
run: ./getopt two bar "one bar" foo
TRUE 2
TRUE 3
TRUE 4
run: ./getopt two bar one bar foo
TRUE 2
FALSE
TRUE 5
*/
return 0;
}
答案 13 :(得分：0)
无耻的插头。我是另一个名为 clip 的命令行解析器的作者。解析器是跨平台的，可与许多不同的编译器配合使用。我已经尝试过 GCC、clang、Turbo C、Open Watcom 甚至 Microsoft Visual C++。