Chuyển đối số vào chương trình C từ dòng lệnh

Question

Vì vậy, tôi đang ở trong Linux và tôi muốn có một chương trình chấp nhận đối số khi bạn thực hiện nó từ dòng lệnh.

Ví dụ,

./myprogram 42 -b -s

Vì vậy, sau đó chương trình sẽ lưu trữ con số 42 như một int và thực hiện một số phần của mã tùy thuộc vào những gì nó được lập luận như -b hoặc -s.

Answer 1

Bạn có thể sử dụng 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; 
} 

Answer 2

Trong C, điều này được thực hiện bằng đối số truyền cho chức năng main() của bạn:

thông tin

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

thêm có thể được tìm thấy trực tuyến như Arguments to main bài viết này.

Answer 3

Hãy xem thư viện getopt; nó khá nhiều tiêu chuẩn vàng cho loại điều này.

Answer 4

Cân nhắc sử dụng getopt_long(). Nó cho phép cả hai lựa chọn ngắn và dài trong bất kỳ sự kết hợp nào.

#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; 
} 

liên quan:

• Which command line commands style do you prefer?
• What is the general syntax of a Unix shell command?

Answer 5

Thay vì getopt(), bạn cũng có thể xem xét sử dụng argp_parse() (một giao diện thay thế cho cùng một thư viện).

Từ libc manual:

getopt là tiêu chuẩn hơn (các ngắn lựa chọn duy nhất phiên bản của nó là một phần của tiêu chuẩn POSIX), nhưng sử dụng argp_parse thường dễ dàng hơn, cho cả rất đơn giản và các cấu trúc rất phức tạp, bởi vì nó có nhiều công việc bẩn hơn cho bạn.

Nhưng tôi luôn hài lòng với tiêu chuẩn getopt.

N.B. GNU getopt với getopt_long là GNU LGPL.

Answer 6

khác đã trúng cái này trên đầu:

• các đối số tiêu chuẩn để main(int argc, char **argv) cung cấp cho bạn truy cập trực tiếp vào dòng lệnh (sau khi đã được đọc sai và tokenized bằng vỏ)
• có rất cơ sở tiêu chuẩn để phân tích cú pháp dòng lệnh: getopt() và getopt_long()

nhưng khi bạn đã nhìn thấy mã để sử dụng chúng là một chút dài dòng, và khá idomatic. Tôi thường đẩy nó ra khỏi cái nhìn với một cái gì đó như:

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); 

điều đó đầu tiên trong chính:

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

Hoặc bạn có thể sử dụng một trong những giải pháp đề xuất trong Argument-parsing helpers for C/UNIX.