促进语义行为中的精神、phoenix::push_back和功能

Question

我尝试了一个小的测试用例，它将接受一个范围，比如5-3，然后将3，4，5推到向量中。我只能考虑使用语义动作方法。但是，我使用phoenix::push_back编写代码的方式似乎行不通。如果我只是按一个数字(如测试3中的'3‘)或占位符(测试2)。精神会起作用的。但是如果我用for循环来推送。那么大小将是0。基本上，那里什么都没有。

#include <fstream>
#include <iostream>
#include <vector>

#define BOOST_SPIRIT_USE_PHOENIX_V3
#include <boost/fusion/adapted/struct.hpp>
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/phoenix.hpp>

namespace qi = boost::spirit::qi;
namespace px = boost::phoenix;

struct varVec
{
  std::vector<unsigned int> uintVec;
};

BOOST_FUSION_ADAPT_STRUCT(varVec,
                          (std::vector<unsigned int>, uintVec))

template<typename Iterator, typename Skipper>
struct listParser : public qi::grammar<Iterator,
                                       varVec(),
                                       Skipper>
{
  listParser() : listParser::base_type(varVecParse)
  {
    using namespace qi;

    varPair =
      uint_ [_a = _1]
      > '-'
      > uint_
      [
        // test 1
        px::bind([](uint lb, uint ub) {
            if (ub < lb) {
              uint temp = ub; ub  = lb; lb = temp; }
            for (unsigned int i = lb; i <= ub; i++)
            {
              px::push_back(qi::_val, i);
              std::cout << "i = " << i << std::endl;
            }
          },
          // parameters
          qi::_a, qi::_1)

        // test 2
        // px::push_back(_val, _1)
        // test 3
        // px::push_back(_val, 3)
        ]
      ;

    varVecParse = '['
      >> varPair
      >> ']'
      ;
  }

  qi::rule<Iterator, std::vector<unsigned int>(), qi::locals<unsigned int>,
           Skipper> varPair;
  qi::rule<Iterator, varVec(), Skipper> varVecParse;
};

int main()
{
  std::string input ("[ 6- 4]\n");
  std::string::const_iterator begin = input.begin();
  std::string::const_iterator end = input.end();

  listParser<std::string::const_iterator, qi::space_type> parser;

  varVec result;

  bool success = qi::phrase_parse(begin, end, parser, qi::space, result);

  unsigned int size = result.uintVec.size();
  std::cout << "size = " << size << std::endl;
  if (size > 0)
    std::cout << "val = " << result.uintVec[0] << std::endl;
  return 0;
}

因此，函数是使范围是上升的顺序，并将其推入无符号的int向量。我猜语义动作中的函数有问题，但不确定是什么问题。

Answer 1

您需要记住，尽管Boost.Phoenix表达式看起来是“正常”表达式，但它们的行为实际上像lambdas，它们需要使用它们所需的任何参数来执行。作为一个简化的示例

std::vector<int> val{};
using px::placeholders::arg1;

px::push_back(px::ref(val),1);
std::cout << val.size() << "\n"; //0

px::push_back(px::ref(val),1)();
std::cout << val.size() << "\n"; //1

px::push_back(arg1,1);
std::cout << val.size() << "\n"; //1

px::push_back(arg1,1)(val);
std::cout << val.size() << "\n"; //2

您的情况类似于arg1示例(但qi::_val稍微复杂一些)。当在解析器语义操作中使用菲尼克斯表达式时，它们将被圣灵“自动”调用，其中包含它们所需的参数，在您的示例中，您没有调用它们，以及从未插入到向量中的uint。你不应该把凤凰代码和“普通”代码混为一谈。因此，您需要摆脱px::push_back (参见魔盒)：

#include <fstream>
#include <iostream>
#include <vector>

#define BOOST_SPIRIT_USE_PHOENIX_V3
#include <boost/fusion/adapted/struct.hpp>
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/phoenix.hpp>

namespace qi = boost::spirit::qi;
namespace px = boost::phoenix;

struct varVec
{
  std::vector<unsigned int> uintVec;
};

BOOST_FUSION_ADAPT_STRUCT(varVec,
                          (std::vector<unsigned int>, uintVec))

template<typename Iterator, typename Skipper>
struct listParser : public qi::grammar<Iterator,
                                       varVec(),
                                       Skipper>
{
  listParser() : listParser::base_type(varVecParse)
  {
    using namespace qi;

    varPair =
      uint_ [_a = _1]
      > '-'
      > uint_
      [ //                 ADDED
        // test 1   vvvvvvvvvvvvvvvvvvvvvv
        px::bind([](std::vector<uint>& val, uint lb, uint ub) {
            if (ub < lb) {
              uint temp = ub; ub  = lb; lb = temp; }
            for (unsigned int i = lb; i <= ub; i++)
            {
              val.push_back(i); //<---CHANGED
              std::cout << "i = " << i << std::endl;
            }
          },
          // parameters
          qi::_val, qi::_a, qi::_1)
        //^^^^^^^^^
        // ADDED

        ]
      ;

    varVecParse = '['
      >> varPair
      >> ']'
      ;
  }

  qi::rule<Iterator, std::vector<unsigned int>(), qi::locals<unsigned int>,
           Skipper> varPair;
  qi::rule<Iterator, varVec(), Skipper> varVecParse;
};

int main()
{
  std::string input ("[ 6- 4]\n");
  std::string::const_iterator begin = input.begin();
  std::string::const_iterator end = input.end();

  listParser<std::string::const_iterator, qi::space_type> parser;

  varVec result;

  bool success = qi::phrase_parse(begin, end, parser, qi::space, result);

  unsigned int size = result.uintVec.size();
  std::cout << "size = " << size << std::endl;
  if (size > 0)
    std::cout << "val = " << result.uintVec[0] << std::endl;
  return 0;
}

另一种可能(不推荐)是一路使用Boost.Phoenix (参见魔盒)：

...
qi::_1_type const upper;
qi::_a_type const lower;
px::local_names::_i_type const cont;

varPair =
  uint_ [lower = _1]
  > '-'
  > uint_
  [
    px::if_(upper<lower)[px::swap(lower,upper)],
    px::let(cont=lower)
    [
        px::for_(px::nothing,cont<=upper,++cont)
        [
            px::push_back(qi::_val,cont),
            px::ref(std::cout) << "i = " << cont << std::endl
        ]
     ]
   ]
  ;
...

PS:另一种可能是在解析后的一个步骤中处理向量的生成。这样，在解析过程中，您只需存储范围的边界，然后就可以轻松地生成实际需要的向量。