c - Getopt 订购，有吗？

Question

我在做一个小程序，意识到我需要用户以正确的顺序输入他的选项，这样我的程序才能正确地完成他的工作，但我认为这是一种应该避免的“错误”，所以我试图让程序“独立于顺序”工作，但这行不通，所以我决定找到一个函数，让 optarg 按照我选择的顺序解析选项，但令我惊讶的是，我可以T FIND ANY，所以我决定编写我的 on getopt 排序函数......问题是，这个工作有一个特定的函数吗？ (而且我白白写了所有这些代码 :( )。如果有一个函数，请告诉我。而且，不管函数是否存在，你们可以看看我写的这段代码.. 。 先感谢您。Obs.: 我想知道是否存在用于该任务的 C 函数。

密码在https://github.com/paolocarrara/getopt_ordering

但这里也是(两个文件):

/*file _getopt.h (first file)*/

#include <stdlib.h>
char **ordering (int *, char **, char *); 

/*file ordering.c (second file)*/

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

#define TRUE    1
#define FALSE   0

int get_line_size (char *line) {
return strlen (line);
}

int verify_if_is_option (char *argv) {

if (argv != NULL) {
    if (argv[0] == '-')
        return TRUE;
    else 
        return FALSE;
}
else
    return FALSE;
}

int problem_counter (int argc, char **argv) {

int i;
int number_of_problens;

for (i = 1, number_of_problens = 0; i < argc; i++)
    if (verify_if_is_option (argv[i]) == TRUE)
        if (get_line_size (argv[i]) > 2)
            number_of_problens++;

return number_of_problens;

}

char **malloc_argv (int argc, char **argv, int t_problens) {

char **new;
int i;

new = malloc ((argc+t_problens)*sizeof(char*));
for (i = 0; i < argc; i++) 
    new[i] = argv[i];
for (; i < argc + t_problens; i++)
    new[i] = NULL;
return new;
}

char *get_problematic_line (int argc, char **argv) {

int i;
char *line = NULL;

for (i = 1; i < argc; i++)
    if (verify_if_is_option (argv[i]) == TRUE)
        if (get_line_size (argv[i]) > 2)
            line = argv[i];
return line;
}

char *get_argument (char *line) {

char *argument;
int i;
argument = malloc ((strlen(line)-1)*sizeof(char));

for (i = 2; i < strlen(line); i++)
    argument[i-2] = line[i];
argument[i-2] = '\0';

return argument;
}

char **push_down (int argc, char **argv, int i) {

for (; argc > i+1; argc--)
    argv[argc-1] = argv[argc-2];
return argv;
}

char **push_one_line_down_from_here (char *line, int argc, char **argv) {

int i;
for (i = 1; i < argc; i++) 
    if (argv[i] == line){
        argv = push_down (argc, argv, i);
        i = argc;
    }
return argv;
}

char **insert_argument_below_this_line (char *line, char *argument, char **argv) {

int i;

for (i = 1; line != argv[i]; i++);
argv[i+1] = argument;
return argv;
}

void remove_argument_from_problematic_line (char *line) {

line[2] = '\0';
}

char **malloc_and_divide (int *argc, char **argv) {

int t_problens;
char *line;
char *argument;

t_problens = problem_counter (*argc, argv);

argv = malloc_argv (*argc, argv, t_problens);

(*argc) +=t_problens;

for (;t_problens > 0; t_problens--) {
    line = get_problematic_line (*argc, argv);
    argument = get_argument (line);
    argv = push_one_line_down_from_here (line, *argc, argv);
    argv = insert_argument_below_this_line (line, argument, argv);
    remove_argument_from_problematic_line(line);
}

return argv;
}

char *litteral_to_dinamic (char *literal) {
int i;
char *dinamic = malloc ((strlen(literal)+1)*sizeof(char));
for (i = 0; i < strlen(literal); i++) dinamic[i] = literal[i];
dinamic[i] = '\0';
return dinamic;
}


char get_desired_option (char *optstring) {
char option;
option = optstring[0];
return option;
}

void remove_option_used (char *optstring) {

int i;

for (i = 1; i <= strlen(optstring); i++)
    optstring[i-1] = optstring[i];
if (optstring[0] == ':')
    remove_option_used (optstring);
}

int is_in_argv (int argc, char **argv, char option) {

int i;

for (i = 1; i < argc; i++)
    if (argv[i][0] == '-' && argv[i][1] == option)
        return TRUE;
return FALSE;
}

int option_have_argument (char **argv, int position) {

if (argv[position+1][0] == '-')
    return TRUE;
else
    return FALSE;
}

int both_have_argument (int argc, char **argv, int position, int i) {

if(i < argc-1){
    if((argv[position+1][0] != '-') && (argv[i+1][0] != '-'))
        return TRUE;
    else 
        return FALSE;
}
else 
    return FALSE;
}

void change_both_arguments (int argc, char **argv, int position, int i) {

char *aux;

aux = argv[position+1];
argv[position+1] = argv[i+1];
argv[i+1] = aux;
}

int first_have_argument (int argc, char **argv, int position) {

if (position < argc-1)
    if (argv[position+1][0] != '-')
        return TRUE;
return FALSE;
}

void change_first_argument (int argc, char **argv, int position, int i) {

char *aux;

aux = argv[position+1];
for (position++; position < i; position++)
    argv[position] = argv[position+1];
argv[i] = aux;

}

int second_have_argument (int argc, char **argv, int i) {

if (i < argc-1)
    if (argv[i+1][0] != '-')
        return TRUE;
return FALSE;
}

void change_second_argument (int argc, char **argv, int position, int i) {

char *aux;
int j;

aux = argv[i+1];
for (j=i+1; j > position; j--)
    argv[j] = argv[j-1];
argv[position+1] = aux;

}

int verify_arguments (int argc, char **argv, int position, int i) {

if (both_have_argument (argc, argv, position, i) == TRUE) {
    change_both_arguments (argc, argv, position, i);
    return position+2;
}
else if (first_have_argument (argc, argv, position) == TRUE) {
    change_first_argument (argc, argv, position, i);
    return position+1;
}
else if (second_have_argument (argc, argv, i) == TRUE) {
    change_second_argument (argc, argv, position, i);
    return position+2;
}
else 
    return position+1;
}


int change_option_position (int argc, char **argv, char option, int position) {

int i;
char *aux;

for (i = 1; i < argc; i++)
    if (argv[i][0] == '-' && argv[i][1] == option) {
        aux = argv[position];
        argv[position] = argv[i];
        argv[i] = aux;
        position = verify_arguments (argc, argv, position, i);
    }
return position;
}

char **organize (int argc, char **argv, char *optstring) {

int position = 1;
char option;

optstring = litteral_to_dinamic (optstring);

while (optstring[0] != '\0') {
    option = get_desired_option (optstring);
    remove_option_used (optstring);
    if ((is_in_argv(argc, argv, option)) ==  TRUE)
        position = change_option_position (argc, argv, option, position);

}

return argv;
}

char **ordering (int *argc, char **argv, char *optstring) {

int i;

argv = malloc_and_divide (argc, argv);

argv = organize (*argc, argv, optstring);

return argv;
}

Answer 1

您是对的，没有函数可以执行您描述的操作。但是，为什么不只声明位图并仅 使用getopt 来设置位图中的值？完成后，您可以检查位图并按您喜欢的顺序处理选项。考虑以下示例，假设需要在任意选项“a”之前处理任意选项“b”。

#define OPTIONS = "ab"
#define flaga = 0x0001; /* corresponds to a */
#define flagb = 0x0002; /* corresponds to b */

unsigned int flags = 0; /* the bitmap */
char ch = '\0' /* the switch char */

while ((ch = getopt(argc, argv, OPTIONS)) != -1) 
{
    switch (ch) {
    case 'a':       /* set flag a */
        flags |= flaga;
        break;
    case 'b':
        flags |= flagb;
        break;
}

if((flags & flagb) == flagb) 
{
    //process flag b
}
if((flags & flaga) == flaga)
{
    //process flag a
}