Sender argumenter inn i C-program fra kommandolinjen

stemmer
28

Så jeg er i Linux, og jeg ønsker å ha et program akseptere argumenter når du kjører det fra kommandolinjen.

For eksempel,

./myprogram 42 -b -s

Så da programmet vil lagre som nummer 42 som en int og utføre visse deler av koden avhengig av hva argumenter det blir som b eller -s.

Publisert på 31/01/2009 klokken 05:17
kilden bruker
På andre språk...                            


6 svar

stemmer
25

I C, gjøres dette ved hjelp av argumenter som sendes til main()funksjonen:

int main(int argc, char *argv[])
{
    int i = 0;
    for (i = 0; i < argc; i++) {
        printf("argv[%d] = %s\n", i, argv[i]);
    }
    return 0;
}

Mer informasjon kan bli funnet på nettet som dette argumenter til hovedartikkelen.

Svarte 31/01/2009 kl. 05:19
kilden bruker

stemmer
6

Ta en titt på getopt bibliotek, det er ganske mye gull standard for denne typen ting.

Svarte 31/01/2009 kl. 05:21
kilden bruker

stemmer
37

Du kan bruke getopt .

 #include <ctype.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>

 int
 main (int argc, char **argv)
 {
   int bflag = 0;
   int sflag = 0;
   int index;
   int c;

   opterr = 0;

   while ((c = getopt (argc, argv, "bs")) != -1)
     switch (c)
       {
       case 'b':
         bflag = 1;
         break;
       case 's':
         sflag = 1;
         break;
       case '?':
         if (isprint (optopt))
           fprintf (stderr, "Unknown option `-%c'.\n", optopt);
         else
           fprintf (stderr,
                    "Unknown option character `\\x%x'.\n",
                    optopt);
         return 1;
       default:
         abort ();
       }

   printf ("bflag = %d, sflag = %d\n", bflag, sflag);

   for (index = optind; index < argc; index++)
     printf ("Non-option argument %s\n", argv[index]);
   return 0;
 }
Svarte 31/01/2009 kl. 05:21
kilden bruker

stemmer
10

Vurder å bruke getopt_long(). Det gjør at både korte og lange flagg i hvilken som helst kombinasjon.

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

/* Flag set by `--verbose'. */
static int verbose_flag;

int
main (int argc, char *argv[])
{
  while (1)
    {
      static struct option long_options[] =
    {
      /* This option set a flag. */
      {"verbose", no_argument,       &verbose_flag, 1},
      /* These options don't set a flag.
         We distinguish them by their indices. */
      {"blip",    no_argument,       0, 'b'},
      {"slip",    no_argument,       0, 's'},
      {0,         0,                 0,  0}
    };
      /* getopt_long stores the option index here. */
      int option_index = 0;

      int c = getopt_long (argc, argv, "bs",
               long_options, &option_index);

      /* Detect the end of the options. */
      if (c == -1)
    break;

      switch (c)
    {
    case 0:
      /* If this option set a flag, do nothing else now. */
      if (long_options[option_index].flag != 0)
        break;
      printf ("option %s", long_options[option_index].name);
      if (optarg)
        printf (" with arg %s", optarg);
      printf ("\n");
      break;
    case 'b':
      puts ("option -b\n");
      break;
    case 's':
      puts ("option -s\n");
      break;
    case '?':
      /* getopt_long already printed an error message. */
      break;

    default:
      abort ();
    }
    }

  if (verbose_flag)
    puts ("verbose flag is set");

  /* Print any remaining command line arguments (not options). */
  if (optind < argc)
    {
      printf ("non-option ARGV-elements: ");
      while (optind < argc)
    printf ("%s ", argv[optind++]);
      putchar ('\n');
    }

  return 0;
}

I slekt:

Svarte 31/01/2009 kl. 06:19
kilden bruker

stemmer
5

I stedet for getopt(), kan du også vurdere å bruke argp_parse()(et alternativt grensesnitt til samme bibliotek).

Fra libc manual :

getopter mer standard (kort-alternativet bare versjon av det er en del av POSIX-standarden), men ved hjelp argp_parseer ofte lettere, både for svært enkle og svært komplekse opsjonsstrukturer, fordi det gjør mer av det skitne arbeidet for deg.

Men jeg var alltid fornøyd med standarden getopt.

NB GNU getoptmed getopt_longer GNU LGPL.

Svarte 31/01/2009 kl. 14:35
kilden bruker

stemmer
4

Andre har truffet denne på hodet:

  • standard argumenter for å main(int argc, char **argv)gi deg direkte tilgang til kommandolinjen (etter at det har blitt revet i stykker og symbolbaserte av skallet)
  • det er veldig standard anlegget for å analysere kommandolinjen: getopt()oggetopt_long()

men som du har sett koden for å bruke dem er litt ordrike, og ganske idomatic. Jeg generelt skyve den ut av syne med noe sånt som:

typedef
struct options_struct {
   int some_flag;
   int other_flage;
   char *use_file;
} opt_t;
/* Parses the command line and fills the options structure, 
 * returns non-zero on error */
int parse_options(opt_t *opts, int argc, char **argv);

Deretter første i hoved:

int main(int argc, char **argv){
   opt_t opts;
   if (parse_options(&opts,argc,argv)){
      ...
   } 
   ...
}

Eller du kan bruke en av løsningene foreslått i Argument-parsing hjelpere for C / UNIX .

Svarte 31/01/2009 kl. 15:02
kilden bruker

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more