Question

之前提出过这个问题，但似乎没有一个答案提供boost式通用编程的替代方案。

与许多人一样，我使用boost：program_options来解析命令行选项。我目前的项目是一个程序来处理数据（例如图像）与操作员的顺序不可互换，例如

添加3然后乘以2
$ manipulate -in someimage.tif -a 3 -m 2

通常与

不同

乘以2然后加3
$ manipulate -in someimage.tif -m 2 -a 3

-in选项将文件内容加载到向量current_image中，命令行上的每个选项都会修改current_image。

但variable_map容器不保留添加选项的顺序。至少没有明确说明。 this post中的答案最接近我的想法，但extra parsing code needed的数量与getopt()的数量大致相同。

有没有人知道在boost提供的容器中存储程序选项顺序的方法？从根本上说不可能吗？或者是否有可能（甚至可以实现）序列容器？

编辑1 我确实发现这个really old post似乎仍然有效，说明是的，你可以迭代一个variables_map。当然，订单实际上并没有指定与命令行上的顺序相同（左边是编译器编写者），所以我猜它仍然可以归类为黑客。
EDIT 2 这还不够，因为选项按选项字符串排序，因此迭代顺序与插入顺序不同。

Answer 1

实际上你所拥有的东西更类似于表达式语法。我建议为此编写一个语法/解析器而不是（ab？）使用program_options。

如果您的程序选择了：使用程序选项。
如果您的程序采用表达式：使用表达式解析器。

一个例子：

<强> Live On Coliru

// #define BOOST_SPIRIT_DEBUG
#include <boost/fusion/adapted/struct.hpp>
#include <boost/fusion/include/io.hpp>
#include <boost/spirit/include/qi.hpp>

namespace qi  = boost::spirit::qi;

struct Operation {
    enum Kind { add, multiply } kind;
    double operand;

    friend std::ostream& operator<<(std::ostream& os, Kind k) {
        switch (k) {
            case add:      return os << "--add";
            case multiply: return os << "--multiply";
        };
        return os << "??";
    }
};

BOOST_FUSION_ADAPT_STRUCT(Operation, (Operation::Kind,kind)(double,operand))

template <typename It, typename Skipper = qi::blank_type> 
   struct expression_grammar : qi::grammar<It, std::vector<Operation>(), Skipper> {
       expression_grammar() : expression_grammar::base_type(start) {
           using namespace qi;

           opkinds.add
               ("-a",         Operation::add)
               ("--add",      Operation::add)
               ("-m",         Operation::multiply)
               ("--multiply", Operation::multiply)
               ;

           option = opkinds > eol > double_;

           start  = *(option > eol);

           BOOST_SPIRIT_DEBUG_NODES((start)(option))
       }
     private:
       qi::symbols<char, Operation::Kind> opkinds;
       qi::rule<It, Operation(), Skipper> option;
       qi::rule<It, std::vector<Operation>(), Skipper> start;
   };

int main(int argc, char const** argv) {
    std::stringstream iss;
    if (argc)
        std::copy(argv+1, argv+argc, std::ostream_iterator<const char*>(iss, "\n"));

    typedef boost::spirit::istream_iterator It;
    expression_grammar<It> grammar;

    It first(iss >> std::noskipws), last;
    std::vector<Operation> operations;
    bool ok = qi::phrase_parse(first, last, grammar, qi::blank, operations);

    if (ok)
    {
        std::cout << "Parse success\n";
        for (auto const& op : operations)
            std::cout << boost::fusion::as_vector(op) << "\n";
    } else
        std::cout << "Parse failed\n";

    if (first!=last)
       std::cout << "Remaining input: '" << std::string(first,last) << "'\n";
}

请注意

我无偿地选择使用eol作为选项分隔符。您可能希望使用'\0'代替。这是最简单的，因为blank队长已经跳过空格/除了/ eol。我很懒：）
您可能想要混合匹配（不要将所有参数视为表达式的一部分）。一个常见的模式是
```
myprogram -x option1 -v -o filename -- my expression grammar follows
```
一种常见的替代模式是使表达式成为单个参数：
```
myprogram -e 'add 5; multiply 32;' -x option1
```
请参阅此方法 Live on Coliru
我在“Parse success”打印时再次懒惰（我不想为operator<<类型实施Operation）

使用#define BOOST_SPIRIT_DEBUG启用调试信息（取消注释第一行）

<start>
  <try>-a\n8\n-m\n7\n-a\n32\n</try>
  <option>
    <try>-a\n8\n-m\n7\n-a\n32\n</try>
    <success>\n-m\n7\n-a\n32\n</success>
    <attributes>[[--add, 8]]</attributes>
  </option>
  <option>
    <try>-m\n7\n-a\n32\n</try>
    <success>\n-a\n32\n</success>
    <attributes>[[--multiply, 7]]</attributes>
  </option>
  <option>
    <try>-a\n32\n</try>
    <success>\n</success>
    <attributes>[[--add, 32]]</attributes>
  </option>
  <option>
    <try></try>
    <fail/>
  </option>
  <success></success>
  <attributes>[[[--add, 8], [--multiply, 7], [--add, 32]]]</attributes>
</start>
Parse success
(--add 8)
(--multiply 7)
(--add 32)

使用序列容器解析命令行选项？

1 个答案: