argparse 是现代 C++ 程序参数解析库。该库是 header-only 的，使用该库需要使用 C++ 17。

argparse 支持位置参数，可选参数

位置参数语法支持：

  • _empty_: 参数命令为空
  • '-': 参数命令为 -
  • '-' decimal-literal: 参数命令为 - 加数字
  • !'-' anything: 不带前缀 - 的任何命令

ArgumentParse 类

constructor

enum class default_arguments : unsigned int {
  none = 0,
  help = 1,
  version = 2,
  all = help | version,
};

explicit ArgumentParser(std::string program_name = {},
                        std::string version = "1.0",
                        default_arguments add_args = default_arguments::all);

ArgumentParser(const ArgumentParser &other)
ArgumentParser &operator=(const ArgumentParser &other)

ArgumentParser(ArgumentParser &&) noexcept = default;
ArgumentParser &operator=(ArgumentParser &&) = default;

构造函数构造一个参数解析器，解析器会根据传入的 add_args 参数设置对应默认参数。默认参数包括 help 和 version。对应的参数如下：

  • help: -h, --help
  • version: -v, --version

add_argument

template <typename... Targs>
Argument &add_argument(Targs... f_args)

添加参数。传入的是变长参数，是构造 Argument 类的第二个参数，即 std::array<std::string_view, N>&& a。

添加参数后，实际内部会构造一个 Argument 对象，然后保存到一个 map 中，key 是命令参数，value 是 Argument 对象。

add_parents

template <typename... Targs>
ArgumentParser &add_parents(const Targs &... f_args)

添加父级 ArgumentParser 对象的参数到该 ArgumentParser 对象中

add_description

ArgumentParser &add_description(std::string description);

添加参数描述

add_epilog

ArgumentParser &add_epilog(std::string epilog)

set_prefix_chars

ArgumentParser &set_prefix_chars(std::string prefix_chars);

设置可选参数的前缀

set_assign_chars

ArgumentParser &set_assign_chars(std::string assign_chars);

设置命令行中赋值字符，默认为 = 。

parse_args

void parse_args(int argc, const char *const argv[]);
void parse_args(const std::vector<std::string> &arguments);

auto parse_known_args(int argc, const char *const argv[]);
std::vector<std::string> parse_known_args(const std::vector<std::string> &arguments)

解析参数

get

template <typename T = std::string>
auto get(std::string_view arg_name);

获取参数值，如果未设置则获取默认值，转换为对应的类型

present

template <typename T = std::string>
auto present(std::string_view arg_name) const -> std::optional<T>

获取参数值，如果未设置，则返回 std::optional 的空值 std::nullopt

is_used

auto is_used(std::string_view arg_name) const

对于用户提供了的可选参数时，返回 true，未提供则返回 false

is_subcommand_used

auto is_subcommand_used(std::string_view subcommand_name) const;

operator[]

Argument &operator[](std::string_view arg_name) const

获取指定命令行参数值

operator<<

friend std::ostream& operator<<(std::ostream &stream, const ArgumentParser &parser) ->

输出流支持，用于打印

help

std::stringstream help() const;

获取帮助信息，用于打印

usage

std::string usage() const;

获取命令行使用说明，用于打印

std::string print_help() const;

add_subparser

void add_subparser(ArgumentParser &parser)

添加子 ArgumentParser

Argument 类

Argument 类中的各个函数都是返回的 Argument&，所以 Argument 函数是支持链式调用的。

constructor

template <std::size_t N, std::size_t... I>
explicit Argument(std::string_view prefix_chars,
                  std::array<std::string_view, N>&& a,
                  std::index_sequence<I...> /*unused*/)

template <std::size_t N>
explicit Argument(std::string_view prefix_chars,
                  std::array<std::string_view, N>&& a)

help

Argument& help(std::string help_text);

设置 --help 展示的帮助中的参数描述。

metavar

Argument& metavar(std::string metavar);

设置 metavar

default

template <typename T>
Argument& default_value(T&& value);

设置参数的默认值

required

Argument& required();

设置参数是否是必须的，如果不是必须的，则是可选的

implicit_value

Argument& implicit_value(std::any value);

设置参数的隐式值

action

template <class F, class... Args>
auto action(F&& callable, Args&&... bound_args);

设置参数执行的动作（函数）

append

Argument& append();

设置参数是否是可重复的，支持多个值

scan

template <char Shape, typename T>
auto scan() -> std::enable_if_t<std::is_arithmetic_v<T>, Argument&>

执行类型转换 action

nargs

Argument& nargs(std::size_t num_args);
Argument& nargs(std::size_t num_args_min, std::size_t num_args_max);
Argument& nargs(nargs_pattern pattern);

通常情况下，一个命令行参数是与一个 action 进行关联的。nargs 可以将多个参数与一个 action 进行关联。

nargs 设置关联参数的个数范围或模式。模式支持 optional, any, at_least_one。各模式对应的范围如下：

  • optional: [0, 1]
  • any: [0, max]
  • at_least_one: [1, max]

remaining

Argument& remaining();

consume

template <typename Iterator>
Iterator consume(Iterator start, Iterator end,
                 std::string_view used_name = {});

validate

// throws std::runtime_error if argument values are not valid
void validate() const;

验证参数是否有效

get_inline_usage

std::string get_inline_usage() const;

获取使用说明字符串

get_arguments_length

std::size_t get_arguments_length() const;

operator<<

friend std::ostream &operator<<(std::ostream &stream,
                                const Argument &argument);

支持输出流，可用于打印

operator!= & operator==

template <typename T>
bool operator!=(const T &rhs) const

template <typename T>
bool operator==(const T &rhs)