Getopt订购，任何？

Question

我正在做一个小程序并意识到我需要用户以正确的顺序输入他的选项，这样我的程序才能正确完成他的工作，但我认为这是一种应该避免的'bug'，所以我试图使程序工作'顺序独立'，但这不起作用，所以我决定找到一个函数，按照我选择的顺序对optarg解析选项，但是，令我惊讶的是，我COULDN' T找到了，所以我决定写一下我的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
}