c++命令行解析开源库cxxopts上手教程

cxxopts

• 简介
  • cxxopts是一个轻量级的C++命令行解析库，它提供了易于使用的API来定义和解析命令行选项。它支持多种类型的选项，并且允许用户自定义选项的处理逻辑。
• 项目地址： cxxopts GitHub

快速入门

轻量级C++选项解析库，支持标准的GNU样式语法。

1. cmake环境配置

include(FetchContent)
FetchContent_Declare(
    cxxopts
    GIT_REPOSITORY https://github.com/jarro2783/cxxopts
    GIT_TAG v3.2.1
    GIT_SHALLOW TRUE)
FetchContent_MakeAvailable(cxxopts)
# 给项目代码链接cxxopts库
target_link_libraries(cxx_opt_guide PRIVATE cxxopts::cxxopts)
1
2
3
4
5
6
7
8
9

2. 定义解析的规则

具体规则请看代码注释，总体来说还是比较通俗易懂的，不需要特别多的解释。

// 1. 导入头文件（只有一个）
#include <cxxopts.hpp>

// 2. 创建一个Options实例
cxxopts::Options options("MyProgram", "One line description of MyProgram");

// 3. 写入可解析的参数
options.add_options()
  ("d,debug", "Enable debugging") // 默认是bool类型
  ("i,integer", "Int param", cxxopts::value<int>()) // 该参数是int类型
  ("f,file", "File name", cxxopts::value<std::string>())
  // vector 传递参数有 2 种方式
  // --value_list=1,2,3,4 一次性传递，确保没有空格
  // -v 1 -v 3 分多次传递，组成一个list
  ("v,value_list", "File name", cxxopts::value<std::vector<double>>());
  ("v,verbose", "Verbose output", cxxopts::value<bool>()->default_value("false")); // 该参数默认是false

// 4. 解析参数
auto result = options.parse(argc, argv);

// 5. 检查参数 d 在命令行出现了几次
int t = result.count("d")

// 6. 获得参数d的值
auto v = result["d"].as<type>()

// 7.(可选) 准许有未知的参数，会忽略该部分值。
// 默认是不接受未知的参数的，会直接报错。
options.allow_unrecognised_options();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

3. 使用例子

我这里用Argv类模拟命令行传参，进行测试，该类取自cxxopts的官方源代码中。
可以看到我在void test_(cxxopts::Options &options) 方法中，对该功能做了测试。

#include <assert.h>
#include <cxxopts.hpp>
#include <iostream>
#include <string>

using namespace std;

class Argv {
public:
  Argv(std::initializer_list<const char *> args)
      : m_argv(new const char *[args.size()]),
        m_argc(static_cast<int>(args.size())) {
    int i = 0;
    auto iter = args.begin();
    while (iter != args.end()) {
      auto len = strlen(*iter) + 1;
      auto ptr = std::unique_ptr<char[]>(new char[len]);

      strcpy(ptr.get(), *iter);
      m_args.push_back(std::move(ptr));
      m_argv.get()[i] = m_args.back().get();

      ++iter;
      ++i;
    }
  }

  const char **argv() const { return m_argv.get(); }

  int argc() const { return m_argc; }

private:
  std::vector<std::unique_ptr<char[]>> m_args{};
  std::unique_ptr<const char *[]> m_argv;
  int m_argc;
};

void test_(cxxopts::Options &options) {
  options.add_options()
    ("long", "a long option")
    ("s,short", "a short option")
    ("quick,brown", "An option with multiple long names and no short name")
    ("f,ox,jumped", "An option with multiple long names and a short name")
    ("over,z,lazy,dog", "An option with multiple long names and a short name, not listed first")
    ("value", "an option with a value", cxxopts::value<std::string>())
    ("a,av", "a short option with a value", cxxopts::value<std::string>())
    ("6,six", "a short number option")
    ("p, space", "an option with space between short and long")
    ("period.delimited", "an option with a period in the long name")
    ("nothing", "won't exist", cxxopts::value<std::string>())
    ;
  Argv argv({
      "tester",
      "--long",
      "-s",
      "--value",
      "value",
      "-a",
      "b",
      "-6",
      "-p",
      "--space",
      "--quick",
      "--ox",
      "-f",
      "--brown",
      "-z",
      "--over",
      "--dog",
      "--lazy",
      "--period.delimited",
  });
  auto **actual_argv = argv.argv();
  auto argc = argv.argc();
  auto result = options.parse(argc, actual_argv);
  assert(result.count("long") == 1);
  assert(result.count("s") == 1);
  assert(result.count("value") == 1);
  assert(result.count("a") == 1);
  assert(result["value"].as<std::string>() == "value");
  assert(result["a"].as<std::string>() == "b");
  assert(result.count("6") == 1);
  assert(result.count("p") == 2);
  assert(result.count("space") == 2);
  assert(result.count("quick") == 2);
  assert(result.count("f") == 2);
  assert(result.count("z") == 4);
  assert(result.count("period.delimited") == 1);

    auto& arguments = result.arguments();
    assert(arguments.size() == 16);
    assert(arguments[0].key() == "long");
    assert(arguments[0].value() == "true");
    assert(arguments[0].as<bool>() == true);

    assert(arguments[1].key() == "short");
    assert(arguments[2].key() == "value");
    assert(arguments[3].key() == "av");
}

int main(int argc, char **argv) {
  cxxopts::Options options("命令解析的标题", "这里写一下介绍");
  test_(options); //具体实现请看该函数
  return 0;

  // 添加一组解析参数
  options.add_options()("b,bar", "Param bar", cxxopts::value<std::string>())(
      "d,debug", "Enable debugging",
      cxxopts::value<bool>()->default_value("false"))(
      "f,foo", "Param foo",
      cxxopts::value<int>()->default_value("10"))("h,help", "Print usage");

// 参加第二组解析参数
  options.add_options()(
      "c,cds", "cds test",
      cxxopts::value<std::string>()->default_value("cds test parameter"));

    // 是否准许未知参数
  // options.allow_unrecognised_options();

  // 解析参数
  auto result = options.parse(argc, argv);

    // 参数是否出现
  if (result.count("help")) {
    std::cout << options.help() << std::endl;
    exit(0);
  }
  // 获取参数值
  bool debug = result["debug"].as<bool>();
  std::string bar;
  if (result.count("bar")) {
    bar = result["bar"].as<std::string>();
    cout << "bar: " << bar << endl;
  }
  int foo = result["foo"].as<int>();
  cout << "foo: " << foo << endl;

  cout << result["c"].as<std::string>();

  return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143