argparse
argparse
option=valueเพียงรวม argparse.hpp เท่านี้คุณก็พร้อมแล้ว
# include < argparse/argparse.hpp > หากต้องการเริ่มแยกวิเคราะห์อาร์กิวเมนต์บรรทัดคำสั่ง ให้สร้าง ArgumentParser
argparse::ArgumentParser program ( " program_name " ); หมายเหตุ: มีอาร์กิวเมนต์ที่สองที่เป็นทางเลือกสำหรับ ArgumentParser ซึ่งเป็นเวอร์ชันของโปรแกรม ตัวอย่าง: argparse::ArgumentParser program("libfoo", "1.9.0");
หมายเหตุ: มีอาร์กิวเมนต์ทางเลือกที่สามและสี่ให้กับ ArgumentParser ซึ่งควบคุมอาร์กิวเมนต์เริ่มต้น ตัวอย่าง: argparse::ArgumentParser program("libfoo", "1.9.0", default_arguments::help, false); ดูอาร์กิวเมนต์เริ่มต้นด้านล่าง
หากต้องการเพิ่มอาร์กิวเมนต์ใหม่ เพียงโทร .add_argument(...) คุณสามารถจัดเตรียมรายการชื่ออาร์กิวเมนต์ที่หลากหลายที่คุณต้องการรวมกลุ่มเข้าด้วยกัน เช่น -v และ --verbose
program.add_argument( " foo " );
program.add_argument( " -v " , " --verbose " ); // parameter packingArgparse รองรับอาร์กิวเมนต์หลากหลายประเภท รวมถึงอาร์กิวเมนต์เชิงตำแหน่ง ทางเลือก และแบบผสม ด้านล่างนี้ คุณสามารถดูวิธีกำหนดค่าแต่ละประเภทเหล่านี้ได้:
นี่คือตัวอย่างของ อาร์กิวเมนต์ตำแหน่ง :
# include < argparse/argparse.hpp >
int main ( int argc, char *argv[]) {
argparse::ArgumentParser program ( " program_name " );
program. add_argument ( " square " )
. help ( " display the square of a given integer " )
. scan < ' i ' , int >();
try {
program. parse_args (argc, argv);
}
catch ( const std:: exception & err) {
std::cerr << err. what () << std::endl;
std::cerr << program;
return 1 ;
}
auto input = program. get < int >( " square " );
std::cout << (input * input) << std::endl;
return 0 ;
}และเรียกใช้รหัส:
foo@bar:/home/dev/ $ ./main 15
225นี่คือสิ่งที่เกิดขึ้น:
add_argument() ใช้เพื่อระบุตัวเลือกบรรทัดคำสั่งที่โปรแกรมยินดียอมรับ ในกรณีนี้ ฉันตั้งชื่อมันว่าสี่เหลี่ยมเพื่อให้สอดคล้องกับฟังก์ชันของมัน.scan เพื่อแปลงข้อมูลที่ผู้ใช้ป้อนให้เป็นจำนวนเต็มparser.get<T>(key) ตอนนี้เรามาดู ข้อโต้แย้งเพิ่มเติม กัน อาร์กิวเมนต์เพิ่มเติมเริ่มต้นด้วย - หรือ -- เช่น --verbose หรือ -a อาร์กิวเมนต์เสริมสามารถวางไว้ที่ใดก็ได้ในลำดับอินพุต
argparse::ArgumentParser program ( " test " );
program.add_argument( " --verbose " )
.help( " increase output verbosity " )
.default_value( false )
.implicit_value( true );
try {
program. parse_args (argc, argv);
}
catch ( const std:: exception & err) {
std::cerr << err. what () << std::endl;
std::cerr << program;
std::exit ( 1 );
}
if (program[ " --verbose " ] == true ) {
std::cout << " Verbosity enabled " << std::endl;
} foo@bar:/home/dev/ $ ./main --verbose
Verbosity enabledนี่คือสิ่งที่เกิดขึ้น:
--verbose โปรดทราบว่าการใช้ .default_value(false) หากไม่ได้ใช้อาร์กิวเมนต์เสริม ค่าของจะถูกตั้งค่าเป็น false โดยอัตโนมัติ.implicit_value(true) ผู้ใช้ระบุว่าตัวเลือกนี้เป็นแฟล็กมากกว่าสิ่งที่ต้องการค่า เมื่อผู้ใช้จัดเตรียมตัวเลือก --verbose ค่าของมันจะถูกตั้งค่าเป็นจริง เมื่อกำหนดอาร์กิวเมนต์ของแฟล็ก คุณสามารถใช้ flag() ซึ่งเหมือนกับ default_value(false).implicit_value(true)
argparse::ArgumentParser program ( " test " );
program.add_argument( " --verbose " )
.help( " increase output verbosity " )
.flag();
try {
program. parse_args (argc, argv);
}
catch ( const std:: exception & err) {
std::cerr << err. what () << std::endl;
std::cerr << program;
std::exit ( 1 );
}
if (program[ " --verbose " ] == true ) {
std::cout << " Verbosity enabled " << std::endl;
} มีสถานการณ์ที่คุณต้องการสร้างอาร์กิวเมนต์เพิ่มเติม ที่จำเป็น ตามที่กล่าวไว้ข้างต้น อาร์กิวเมนต์ทางเลือกจะขึ้นต้นด้วย - หรือ -- คุณสามารถกำหนดให้อาร์กิวเมนต์ประเภทนี้จำเป็นได้ เช่น:
program.add_argument( " -o " , " --output " )
.required()
.help( " specify the output file. " );หากผู้ใช้ไม่ได้ระบุค่าสำหรับพารามิเตอร์นี้ ข้อยกเว้นจะเกิดขึ้น
หรือคุณสามารถระบุค่าเริ่มต้นได้ดังนี้:
program.add_argument( " -o " , " --output " )
.default_value(std::string( " - " ))
.required()
.help( " specify the output file. " );หากคุณต้องการให้อาร์กิวเมนต์เสริมปรากฏแต่ไม่มีค่าเริ่มต้นที่ดี คุณสามารถรวมการทดสอบและการเข้าถึงอาร์กิวเมนต์ได้ดังต่อไปนี้:
if ( auto fn = program.present( " -o " )) {
do_something_with (*fn);
} เช่นเดียวกับ get เมธอด present ก็ยอมรับอาร์กิวเมนต์เทมเพลตเช่นกัน แต่แทนที่จะส่งคืน T parser.present<T>(key) ส่งคืน std::optional<T> ดังนั้นเมื่อผู้ใช้ไม่ได้ระบุค่าให้กับพารามิเตอร์นี้ ค่าที่ส่งคืนจะเปรียบเทียบเท่ากับ std::nullopt
หากคุณต้องการทราบว่าผู้ใช้ระบุค่าสำหรับอาร์กิวเมนต์ที่มี .default_value หรือไม่ ให้ตรวจสอบว่าอาร์กิวเมนต์ .is_used() หรือไม่
program.add_argument( " --color " )
.default_value(std::string{ " orange " }) // might otherwise be type const char* leading to an error when trying program.get<std::string>
.help( " specify the cat's fur color " );
try {
program. parse_args (argc, argv); // Example: ./main --color orange
}
catch ( const std:: exception & err) {
std::cerr << err. what () << std::endl;
std::cerr << program;
std::exit ( 1 );
}
auto color = program.get<std::string>( " --color " ); // "orange"
auto explicit_color = program.is_used( " --color " ); // true, user provided orange คุณอาจต้องการอนุญาตให้มีการทำซ้ำอาร์กิวเมนต์เพิ่มเติมและรวบรวมค่าทั้งหมดไว้ในที่เดียว
program.add_argument( " --color " )
.default_value<std::vector<std::string>>({ " orange " })
.append()
.help( " specify the cat's fur color " );
try {
program. parse_args (argc, argv); // Example: ./main --color red --color green --color blue
}
catch ( const std:: exception & err) {
std::cerr << err. what () << std::endl;
std::cerr << program;
std::exit ( 1 );
}
auto colors = program.get<std::vector<std::string>>( " --color " ); // {"red", "green", "blue"} โปรดสังเกตว่า .default_value ได้รับพารามิเตอร์เทมเพลตที่ชัดเจนเพื่อให้ตรงกับประเภทที่คุณต้องการ . .get
รูปแบบทั่วไปคือการทำซ้ำอาร์กิวเมนต์เพื่อระบุค่าที่มากขึ้น
int verbosity = 0 ;
program.add_argument( " -V " , " --verbose " )
.action([&]( const auto &) { ++verbosity; })
.append()
.default_value( false )
.implicit_value( true )
.nargs( 0 );
program.parse_args(argc, argv); // Example: ./main -VVVV
std::cout << " verbose level: " << verbosity << std::endl; // verbose level: 4 สร้างกลุ่มที่ไม่เกิดร่วมกันโดยใช้ program.add_mutually_exclusive_group(required = false) `argparse`` จะทำให้แน่ใจว่ามีเพียงหนึ่งในอาร์กิวเมนต์ในกลุ่มที่ไม่เกิดร่วมกันเท่านั้นที่ปรากฏบนบรรทัดคำสั่ง:
auto &group = program.add_mutually_exclusive_group();
group.add_argument( " --first " );
group.add_argument( " --second " );ด้วยการใช้งานต่อไปนี้จะทำให้เกิดข้อผิดพลาด:
foo@bar:/home/dev/ $ ./main --first 1 --second 2
Argument '--second VAR' not allowed with '--first VAR' ฟังก์ชัน add_mutually_exclusive_group() ยังยอมรับอาร์กิวเมนต์ required เพื่อระบุว่าต้องมีอาร์กิวเมนต์ที่ไม่เกิดร่วมกันอย่างน้อยหนึ่งรายการ:
auto &group = program.add_mutually_exclusive_group( true );
group.add_argument( " --first " );
group.add_argument( " --second " );ด้วยการใช้งานต่อไปนี้จะทำให้เกิดข้อผิดพลาด:
foo@bar:/home/dev/ $ ./main
One of the arguments '--first VAR' or '--second VAR' is required เป็นไปได้ที่จะผูกอาร์กิวเมนต์กับตัวแปรที่เก็บค่าของมัน เป็นทางเลือกแทนการเรียก program.get<T>(arg_name) หรือ program[arg_name] อย่างชัดเจน
ขณะนี้มีการนำไปใช้สำหรับตัวแปรประเภท bool (ซึ่งยังเรียกโดยปริยาย flag() ), int , double , std::string , std::vector<std::string> และ std::vector<int> หากไม่ได้ระบุอาร์กิวเมนต์ในบรรทัดคำสั่ง ค่าเริ่มต้น (หากตั้งค่าไว้) จะถูกตั้งค่าเป็นตัวแปร
bool flagvar = false ;
program.add_argument( " --flagvar " ).store_into(flagvar);
int intvar = 0 ;
program.add_argument( " --intvar " ).store_into(intvar);
double doublevar = 0 ;
program.add_argument( " --doublevar " ).store_into(doublevar);
std::string strvar;
program.add_argument( " --strvar " ).store_into(strvar);
std::vector<std::string> strvar_repeated;
program.add_argument( " --strvar-repeated " ).append().store_into(strvar_repeated);
std::vector<std::string> strvar_multi_valued;
program.add_argument( " --strvar-multi-valued " ).nargs( 2 ).store_into(strvar_multi_valued);
std::vector< int > intvar_repeated;
program.add_argument( " --intvar-repeated " ).append().store_into(intvar_repeated);
std::vector< int > intvar_multi_valued;
program.add_argument( " --intvar-multi-valued " ).nargs( 2 ).store_into(intvar_multi_valued); อาร์กิวเมนต์เพิ่มเติมเริ่มต้นด้วย - argparse สามารถจัดการตัวเลขติดลบได้หรือไม่ คำตอบคือใช่!
argparse::ArgumentParser program;
program.add_argument( " integer " )
.help( " Input number " )
.scan< ' i ' , int >();
program.add_argument( " floats " )
.help( " Vector of floats " )
.nargs( 4 )
.scan< ' g ' , float >();
try {
program. parse_args (argc, argv);
}
catch ( const std:: exception & err) {
std::cerr << err. what () << std::endl;
std::cerr << program;
std::exit ( 1 );
}
// Some code to print arguments foo@bar:/home/dev/ $ ./main -5 -1.1 -3.1415 -3.1e2 -4.51329E3
integer : -5
floats : -1.1 -3.1415 -310 -4513.29 ดังที่คุณเห็นที่นี่ argparse รองรับจำนวนเต็มลบ จำนวนทศนิยมที่เป็นลบ และสัญกรณ์ทางวิทยาศาสตร์
argparse::ArgumentParser program ( " main " );
program.add_argument( " square " )
.help( " display the square of a given number " )
.scan< ' i ' , int >();
program.add_argument( " --verbose " )
.default_value( false )
.implicit_value( true );
try {
program. parse_args (argc, argv);
}
catch ( const std:: exception & err) {
std::cerr << err. what () << std::endl;
std::cerr << program;
std::exit ( 1 );
}
int input = program.get< int >( " square " );
if (program[ " --verbose " ] == true ) {
std::cout << " The square of " << input << " is " << (input * input) << std::endl;
}
else {
std::cout << (input * input) << std::endl;
} foo@bar:/home/dev/ $ ./main 4
16
foo@bar:/home/dev/ $ ./main 4 --verbose
The square of 4 is 16
foo@bar:/home/dev/ $ ./main --verbose 4
The square of 4 is 16 std::cout << program พิมพ์ข้อความช่วยเหลือ รวมถึงการใช้งานโปรแกรมและข้อมูลเกี่ยวกับข้อโต้แย้งที่ลงทะเบียนกับ ArgumentParser สำหรับตัวอย่างก่อนหน้านี้ นี่คือข้อความช่วยเหลือเริ่มต้น:
foo@bar:/home/dev/$ ./main --help
Usage: main [-h] [--verbose] square
Positional arguments:
square display the square of a given number
Optional arguments:
-h, --help shows help message and exits
-v, --version prints version information and exits
--verbose
คุณอาจได้รับข้อความช่วยเหลือในรูปแบบสตริงผ่าน program.help().str()
ArgumentParser::add_description จะเพิ่มข้อความก่อนข้อมูลอาร์กิวเมนต์โดยละเอียด ArgumentParser::add_epilog จะเพิ่มข้อความหลังเอาต์พุตวิธีใช้อื่นๆ ทั้งหมด
# include < argparse/argparse.hpp >
int main ( int argc, char *argv[]) {
argparse::ArgumentParser program ( " main " );
program. add_argument ( " thing " ). help ( " Thing to use. " ). metavar ( " THING " );
program. add_argument ( " --member " ). help ( " The alias for the member to pass to. " ). metavar ( " ALIAS " );
program. add_argument ( " --verbose " ). default_value ( false ). implicit_value ( true );
program. add_description ( " Forward a thing to the next member. " );
program. add_epilog ( " Possible things include betingalw, chiz, and res. " );
program. parse_args (argc, argv);
std::cout << program << std::endl;
} Usage: main [-h] [--member ALIAS] [--verbose] THING
Forward a thing to the next member.
Positional arguments:
THING Thing to use.
Optional arguments:
-h, --help shows help message and exits
-v, --version prints version information and exits
--member ALIAS The alias for the member to pass to.
--verbose
Possible things include betingalw, chiz, and res. วัตถุ ArgumentParser มักจะเชื่อมโยงอาร์กิวเมนต์บรรทัดคำสั่งเดียวกับการดำเนินการเดียวที่จะดำเนินการ .nargs เชื่อมโยงอาร์กิวเมนต์บรรทัดคำสั่งจำนวนต่างกันด้วยการดำเนินการเดียว เมื่อใช้ nargs(N) อาร์กิวเมนต์ N รายการจากบรรทัดคำสั่งจะถูกรวบรวมเข้าด้วยกันเป็นรายการ
argparse::ArgumentParser program ( " main " );
program.add_argument( " --input_files " )
.help( " The list of input files " )
.nargs( 2 );
try {
program. parse_args (argc, argv); // Example: ./main --input_files config.yml System.xml
}
catch ( const std:: exception & err) {
std::cerr << err. what () << std::endl;
std::cerr << program;
std::exit ( 1 );
}
auto files = program.get<std::vector<std::string>>( " --input_files " ); // {"config.yml", "System.xml"} ArgumentParser.get<T>() มีความเชี่ยวชาญสำหรับ std::vector และ std::list ดังนั้นตัวแปรต่อไปนี้ . .get<std::list> ก็ใช้งานได้เช่นกัน
auto files = program.get<std::list<std::string>>( " --input_files " ); // {"config.yml", "System.xml"} การใช้ .scan เราสามารถสร้างรายการประเภทค่าที่ต้องการจากอาร์กิวเมนต์บรรทัดคำสั่งได้อย่างรวดเร็ว นี่คือตัวอย่าง:
argparse::ArgumentParser program ( " main " );
program.add_argument( " --query_point " )
.help( " 3D query point " )
.nargs( 3 )
.default_value(std::vector< double >{ 0.0 , 0.0 , 0.0 })
.scan< ' g ' , double >();
try {
program. parse_args (argc, argv); // Example: ./main --query_point 3.5 4.7 9.2
}
catch ( const std:: exception & err) {
std::cerr << err. what () << std::endl;
std::cerr << program;
std::exit ( 1 );
}
auto query_point = program.get<std::vector< double >>( " --query_point " ); // {3.5, 4.7, 9.2} คุณยังสามารถสร้างรายการอาร์กิวเมนต์ที่มีความยาวผันแปรได้ด้วย .nargs ด้านล่างนี้เป็นตัวอย่างบางส่วน
program.add_argument( " --input_files " )
.nargs( 1 , 3 ); // This accepts 1 to 3 arguments.รูปแบบที่มีประโยชน์บางอย่างถูกกำหนดไว้เช่น "?", "*", "+" ของ argparse ใน Python
program.add_argument( " --input_files " )
.nargs(argparse::nargs_pattern::any); // "*" in Python. This accepts any number of arguments including 0. program.add_argument( " --input_files " )
.nargs(argparse::nargs_pattern::at_least_one); // "+" in Python. This accepts one or more number of arguments. program.add_argument( " --input_files " )
.nargs(argparse::nargs_pattern::optional); // "?" in Python. This accepts an argument optionally. อาร์กิวเมนต์แบบผสมเป็นอาร์กิวเมนต์ทางเลือกที่รวมกันและจัดให้มีเป็นอาร์กิวเมนต์เดียว ตัวอย่าง: ps -aux
argparse::ArgumentParser program ( " test " );
program.add_argument( " -a " )
.default_value( false )
.implicit_value( true );
program.add_argument( " -b " )
.default_value( false )
.implicit_value( true );
program.add_argument( " -c " )
.nargs( 2 )
.default_value(std::vector< float >{ 0 . 0f , 0 . 0f })
.scan< ' g ' , float >();
try {
program. parse_args (argc, argv); // Example: ./main -abc 1.95 2.47
}
catch ( const std:: exception & err) {
std::cerr << err. what () << std::endl;
std::cerr << program;
std::exit ( 1 );
}
auto a = program.get< bool >( " -a " ); // true
auto b = program.get< bool >( " -b " ); // true
auto c = program.get<std::vector< float >>( " -c " ); // {1.95, 2.47}
// / Some code that prints parsed arguments foo@bar:/home/dev/ $ ./main -ac 3.14 2.718
a = true
b = false
c = {3.14, 2.718}
foo@bar:/home/dev/ $ ./main -cb
a = false
b = true
c = {0.0, 0.0}นี่คือสิ่งที่เกิดขึ้น:
-a , -b และ -c-a และ -b เป็นอาร์กิวเมนต์สลับ-c ต้องการตัวเลขทศนิยม 2 ตัวจากบรรทัดคำสั่ง-abc หรือ -bac หรือ -cab ใช้งานได้กับชื่ออาร์กิวเมนต์ที่มีอักขระตัวเดียวแบบสั้นเท่านั้น-a และ -b กลายเป็นจริง-c.default_valueสำหรับอินพุต ผู้ใช้สามารถแสดงประเภทดั้งเดิมสำหรับค่าได้
เมธอด .scan<Shape, T> พยายามแปลง std::string เข้าเป็น T ตามตัวระบุการแปลง Shape ข้อยกเว้น std::invalid_argument หรือ std::range_error ถูกส่งออกมาเนื่องจากมีข้อผิดพลาด
program.add_argument( " -x " )
.scan< ' d ' , int >();
program.add_argument( " scale " )
.scan< ' g ' , double >(); Shape จะระบุว่าอินพุต "มีลักษณะอย่างไร" และอาร์กิวเมนต์เทมเพลตประเภทจะระบุค่าที่ส่งคืนของการดำเนินการที่กำหนดไว้ล่วงหน้า ประเภทที่ยอมรับได้คือจุดลอยตัว (เช่น float, double, long double) และอินทิกรัล (เช่น อักขระที่ลงนาม, short, int, long, long long)
ไวยากรณ์เป็นไปตาม std::from_chars แต่ไม่ได้ซ้ำกันทุกประการ ตัวอย่างเช่น ตัวเลขฐานสิบหกอาจเริ่มต้นด้วย 0x หรือ 0X และตัวเลขที่มีศูนย์นำหน้าอาจถือเป็นค่าฐานแปด
| รูปร่าง | การตีความ |
|---|---|
| 'ก' หรือ 'ก' | จุดลอยตัวฐานสิบหก |
| 'อี' หรือ 'อี' | สัญกรณ์วิทยาศาสตร์ (จุดลอยตัว) |
| 'ฉ' หรือ 'ฉ' | สัญกรณ์คงที่ (จุดลอยตัว) |
| 'ก' หรือ 'จี' | รูปแบบทั่วไป (ทั้งแบบตายตัวหรือแบบวิทยาศาสตร์) |
| 'd' | ทศนิยม |
| 'ฉัน' | std::from_chars ไวยากรณ์ที่มีฐาน == 10 |
| 'โอ' | ฐานแปด (ไม่ได้ลงนาม) |
| 'คุณ' | ทศนิยม (ไม่ได้ลงนาม) |
| 'x' หรือ 'X' | เลขฐานสิบหก (ไม่ได้ลงนาม) |
argparse จัดเตรียมอาร์กิวเมนต์และการดำเนินการที่กำหนดไว้ล่วงหน้าสำหรับ -h / --help และ -v / --version ตามค่าเริ่มต้น การดำเนินการเหล่านี้จะ ออกจาก โปรแกรมหลังจากแสดงวิธีใช้หรือข้อความเวอร์ชันตามลำดับ ทางออกนี้ไม่ได้เรียกตัวทำลาย โดยข้ามการล้างข้อมูลทรัพยากรที่ได้รับ
อาร์กิวเมนต์เริ่มต้นเหล่านี้สามารถปิดใช้งานได้ในระหว่างการสร้าง ArgumentParser เพื่อให้คุณสามารถจัดการอาร์กิวเมนต์เหล่านี้ได้ในแบบของคุณเอง (โปรดทราบว่าต้องรวมชื่อโปรแกรมและเวอร์ชันเมื่อเลือกอาร์กิวเมนต์เริ่มต้น)
argparse::ArgumentParser program ( " test " , " 1.0 " , default_arguments::none);
program.add_argument( " -h " , " --help " )
.action([=]( const std::string& s) {
std::cout << help (). str ();
})
.default_value( false )
.help( " shows help message " )
.implicit_value( true )
.nargs( 0 ); ข้อมูลโค้ดด้านบนจะแสดงข้อความช่วยเหลือและทำงานต่อไป ไม่รองรับอาร์กิวเมนต์ --version
ค่าเริ่มต้นคือ default_arguments::all สำหรับอาร์กิวเมนต์ที่รวมไว้ จะไม่มีการเพิ่มอาร์กิวเมนต์เริ่มต้นด้วย default_arguments::none default_arguments::help และ default_arguments::version จะเพิ่ม --help และ --version ทีละรายการ
อาร์กิวเมนต์เริ่มต้นสามารถใช้ได้ในขณะที่ปิดใช้งานการออกเริ่มต้นด้วยอาร์กิวเมนต์เหล่านี้ อาร์กิวเมนต์ที่สี่ของ ArgumentParser ( exit_on_default_arguments ) เป็นแฟล็กบูลที่มีค่า จริง เริ่มต้น การเรียกต่อไปนี้จะคง --help และ --version แต่จะไม่ออกเมื่อใช้อาร์กิวเมนต์เหล่านั้น
argparse::ArgumentParser program ( " test " , " 1.0 " , default_arguments::all, false ) argparse รองรับการรวบรวมอาร์กิวเมนต์ "ที่เหลืออยู่" ที่ส่วนท้ายของคำสั่ง เช่น เพื่อใช้ในคอมไพเลอร์:
foo@bar:/home/dev/ $ compiler file1 file2 file3 หากต้องการเปิดใช้งานสิ่งนี้ เพียงสร้างอาร์กิวเมนต์และทำเครื่องหมายว่า remaining อาร์กิวเมนต์ที่เหลือทั้งหมดที่ส่งผ่านไปยัง argparse จะถูกรวบรวมไว้ที่นี่
argparse::ArgumentParser program ( " compiler " );
program.add_argument( " files " )
.remaining();
try {
program. parse_args (argc, argv);
}
catch ( const std:: exception & err) {
std::cerr << err. what () << std::endl;
std::cerr << program;
std::exit ( 1 );
}
try {
auto files = program. get <std::vector<std::string>>( " files " );
std::cout << files. size () << " files provided " << std::endl;
for ( auto & file : files)
std::cout << file << std::endl;
} catch (std::logic_error& e) {
std::cout << " No files provided " << std::endl;
}เมื่อไม่มีการโต้แย้ง:
foo@bar:/home/dev/ $ ./compiler
No files providedและเมื่อมีการระบุอาร์กิวเมนต์หลายข้อ:
foo@bar:/home/dev/ $ ./compiler foo.txt bar.txt baz.txt
3 files provided
foo.txt
bar.txt
baz.txtกระบวนการรวบรวมข้อโต้แย้งที่เหลือก็เล่นได้ดีกับข้อโต้แย้งที่เป็นทางเลือกเช่นกัน:
