X3：非终端解析器上的链接器错误（未解析的外部符号“parse_rule”）

Question

首先，我使用的是 MSVC 2017（最新版本）。 这是我的非终端解析器代码：

播放器.hpp

namespace parse
{
    namespace impl
    {
        namespace x3 = boost::spirit::x3;

        struct _tag;

        using player_type = x3::rule<_tag, PlayerIterator>;
        using player_vector_type = x3::rule<_tag, std::vector<PlayerIterator>>;
        BOOST_SPIRIT_DECLARE(player_type);
        BOOST_SPIRIT_DECLARE(player_vector_type);
    }; //impl

    impl::player_type player();
    impl::player_vector_type player_vector();
}; //parse

播放器.cpp

namespace parse
{
    namespace impl
    {
        const player_type player = "player";
        const player_vector_type player_vector = "player_vector";
        auto player_find = [](auto &ctx)
        {
            auto &attr = x3::_attr(ctx);
            if(attr.which() == 0)
                return x3::_val(ctx) = PlayerManager::find(boost::get<int>(attr));
            return x3::_val(ctx) = PlayerManager::find(boost::get<std::string>(attr));
        };
        auto player_vector_find = [](auto &ctx)
        {
            return x3::_val(ctx) = PlayerManager::vector_find(x3::_attr(ctx));
        };
        auto const player_def = (x3::int_ | (+x3::char_))[player_find];
        auto const player_vector_def = (((+x3::char_)[player_vector_find]));
        BOOST_SPIRIT_DEFINE(player);
        BOOST_SPIRIT_DEFINE(player_vector);
        BOOST_SPIRIT_INSTANTIATE(player_type, iterator_type, context_type);
        BOOST_SPIRIT_INSTANTIATE(player_vector_type, iterator_type, context_type);
    } //impl
    parse::impl::player_type player() { return impl::player; }
    parse::impl::player_vector_type player_vector() { return impl::player_vector; }
}//parse

我收到有关“引用了未解析的外部符号”的链接器 LNK2019 错误：
Pastebin.com link with the errors 关于他们的任何想法？ 提前致谢。

编辑： 我在源文件中就是这样称呼它的：

void test(std::string &params)
{
    std::tuple<PlayerIterator, std::vector<PlayerIterator>, std::string> tuple;
    if (!x3::phrase_parse(params.begin(), params.end(), parse::player()>> parse::player_vector() >> (+x3::char_), x3::space,tuple))
    {
        std::cout << "Error: Parsing failed" << std::endl;
        return;
    }
    std::cout << "Parsing succeded" << std::endl;
    std::cout << "Found player, size of player vector: "<< std::get<1>(tuple).size() << ", also parsed string:" << std::get<2>(tuple);
    return;
};

Answer 1

我愿意赌 10 美元，您在实例化时与上下文或迭代器类型不匹配。

例如在您的test 函数中，参数是std::string&，因此params.begin() 将是std::string::iterator。如果您将iterator_type 配置如下：

using iterator_type = std::string::const_iterator; // very sensible!

由于迭代器类型与实际需要的不匹配，您将有未解析的外部变量。

上下文也一样。为了匹配您的调用，它必须是：

using context_type = x3::phrase_parse_context<x3::space_type>::type;

很遗憾，您没有显示整个代码，所以您必须自己检查。

注意事项

1. 重复使用标签类型是灾难的根源。我不认为它可以工作。规则标签是在分开的编译单元的情况下调度实现功能的东西。修复它：

   using player_type        = x3::rule<struct player_tag,        PlayerIterator>;
   using player_vector_type = x3::rule<struct player_vector_tag, std::vector<PlayerIterator>>;
   

2. 复制规则似乎很浪费，考虑引用返回：

   impl::player_type const& player(); impl::player_vector_type const& player_vector();

   注意：这应该没问题。 static initialization order fiasco

3. 在变体上使用which() 是一种反模式。你可以替换

   auto player_find = [](auto &ctx) {
       auto &attr = x3::_attr(ctx);
       if (attr.which() == 0)
           return x3::_val(ctx) = PlayerManager::find(boost::get<int>(attr));
       return x3::_val(ctx) = PlayerManager::find(boost::get<std::string>(attr));
   };
   

   有

   auto find = [](auto const& key) { return PlayerManager::find(key); };
   auto player_find = [](auto &ctx) {
       return x3::_val(ctx) = boost::apply_visitor(find, x3::_attr(ctx));
   };
   

4. (+x3::char_) 始终匹配所有输入

5. (+x3::graph) 仍然匹配所有输入，因为船长

6. 相反，你想要一个词位：

   auto const name              = x3::lexeme[+x3::graph];
   auto const player_def        = (x3::int_ | name) [player_find];
   auto const player_vector_def = name[ player_vector_find];
   

7. 我可以建议更简洁地编写test 函数：

   void test(std::string const &params) {
       auto comment_ = x3::lexeme[+x3::char_];
   
       PlayerIterator player;
       PlayerIterators vec;
       std::string comment;
       auto tuple = std::tie(player, vec, comment);
   
       if (phrase_parse(params.cbegin(), params.cend(), parse::player() >> parse::player_vector() >> comment_, x3::space, tuple)) {
           std::cout << "Parsing succeded" << std::endl;
           std::cout << "Found player, size of player vector: " << vec.size() << "\n";
           std::cout << "Also parsed string: " << std::quoted(comment);
       } else {
           std::cout << "Error: Parsing failed" << std::endl;
       }
   }
   

完整演示

看Live On Wandbox

• stuff.h

  包含模型PlayerManager

  #pragma once
  #include <string>
  #include <vector>
  #include <iostream>
  
  struct PlayerIterator { };
  using PlayerIterators = std::vector<PlayerIterator>;
  
  struct PlayerManager {
      static PlayerIterator              find(std::string const&)        { std::cout << __PRETTY_FUNCTION__ << "\n"; return {}; } 
      static PlayerIterator              find(int)                       { std::cout << __PRETTY_FUNCTION__ << "\n"; return {}; } 
      static PlayerIterators vector_find(std::string const&) { std::cout << __PRETTY_FUNCTION__ << "\n"; return {}; } 
  };
  

• test.h

  #pragma once
  #include <boost/spirit/home/x3.hpp>
  #include <boost/fusion/adapted.hpp>
  #include "stuff.h"
  
  namespace x3 = boost::spirit::x3;
  
  namespace parse
  {
      namespace impl
      {
          using player_type        = x3::rule<struct player_tag,        PlayerIterator>;
          using player_vector_type = x3::rule<struct player_vector_tag, PlayerIterators>;
  
          BOOST_SPIRIT_DECLARE(player_type)
          BOOST_SPIRIT_DECLARE(player_vector_type)
      } //impl
  
      impl::player_type const& player();
      impl::player_vector_type const& player_vector();
  } //parse
  

• test.cpp

  #include "stuff.h"
  #include "test.h"
  
  using iterator_type = std::string::const_iterator;
  using context_type = x3::phrase_parse_context<x3::space_type>::type;
  
  namespace parse {
      namespace impl {
          const player_type player               = "player";
          const player_vector_type player_vector = "player_vector";
  
          auto find               = [](auto const& key) { return PlayerManager::find(key); } ;
          auto player_find        = [](auto &ctx)       { return x3::_val(ctx) = boost::apply_visitor(find, x3::_attr(ctx)); } ;
          auto player_vector_find = [](auto &ctx)       { return x3::_val(ctx) = PlayerManager::vector_find(x3::_attr(ctx)); } ;
  
          auto const name              = x3::lexeme[+x3::graph];
          auto const player_def        = (x3::int_ | name) [player_find];
          auto const player_vector_def = name[ player_vector_find];
  
          BOOST_SPIRIT_DEFINE(player)
          BOOST_SPIRIT_DEFINE(player_vector)
  
          BOOST_SPIRIT_INSTANTIATE(player_type,        iterator_type, context_type)
          BOOST_SPIRIT_INSTANTIATE(player_vector_type, iterator_type, context_type)
      } // namespace impl
  
      parse::impl::player_type const& player()               { return impl::player; }
      parse::impl::player_vector_type const& player_vector() { return impl::player_vector; }
  } // namespace parse
  

• main.cpp

  #include "stuff.h"
  #include "test.h"
  #include <iostream>
  #include <iomanip>
  
  void test(std::string const &params) {
      auto comment_ = x3::lexeme[+x3::char_];
  
      PlayerIterator player;
      PlayerIterators vec;
      std::string comment;
      auto tuple = std::tie(player, vec, comment);
  
      if (phrase_parse(params.cbegin(), params.cend(), parse::player() >> parse::player_vector() >> comment_, x3::space, tuple)) {
          std::cout << "Parsing succeded" << std::endl;
          std::cout << "Found player, size of player vector: " << vec.size() << "\n";
          std::cout << "Also parsed string: " << std::quoted(comment);
      } else {
          std::cout << "Error: Parsing failed" << std::endl;
      }
  }
  
  int main() {
      test("42 someword # bogus trailing comment");
  }
  

打印：

static PlayerIterator PlayerManager::find(int)
static PlayerIterators PlayerManager::vector_find(const std::string &)
Parsing succeded
Found player, size of player vector: 0
Also parsed string: "# bogus trailing comment"