Boost 与本地人一起提高精神调试规则

当my_规则具有某些自定义类型的局部变量时，我无法在调试模式下编译代码（使用BOOST_SPIRIT_debug_节点（my_规则））的代码

• 带有规则

  qi:：locals

  的第一个版本可以
• 规则为qi:：locals的第二个版本仍然可以
• 规则为qi:：locals的当前版本未编译

错误：

运算符>qi:：char（‘，’）>>qi:：int_u[push_back（u b，u 1）][_val=b]；
启动调试节点（启动）；
}
//第一个版本OK:qi:：规则开始；
//第二个版本OK:qi:：规则开始；
qi：：规则开始；
};
}
////////////////////////////////////////////////////////////////////////////
//主程序
////////////////////////////////////////////////////////////////////////////
int
main（）
{
std：：cout首先。。。
你到底想达到什么目的？整个语法可能是
start=qi:：int_u%'，；
并且仍然具有完全相同的效果。请参阅

你的问题:
遗憾的是，您需要使用
运算符。您到底想实现什么？整个语法可能是
start=qi:：int_u%'，“
，但仍然具有完全相同的效果。请参见比较：是的，但我需要局部变量来处理更复杂的情况。我过度简化了代码以突出编译问题。好的。我相信您。我只是警报，因为它是一种反模式，具有最终作为属性返回的本地（毕竟属性已经存在）。如果您不这样做，请继续。谢谢。我确实知道ADL的微妙之处。定义用户类也可以解决编译错误。类myVec:public std:：vector{friend std：：奥斯特雷姆和接线员干杯。也请看一看
std::ostream& >    operator<< (std::ostream& os, std::vector<int> const& art)

#define BOOST_SPIRIT_DEBUG
#if !defined(BOOST_SPIRIT_DEBUG_OUT)
#define BOOST_SPIRIT_DEBUG_OUT std::cerr
#endif

#include <tuple>

#include <boost/config/warning_disable.hpp>
#include <boost/spirit/include/qi.hpp>

#include <boost/spirit/include/phoenix_core.hpp>
#include <boost/spirit/include/phoenix_operator.hpp>
#include <boost/spirit/include/phoenix_fusion.hpp>
#include <boost/spirit/include/phoenix_stl.hpp>
#include <boost/spirit/include/phoenix_object.hpp>

#include <iostream>
#include <string>
#include <vector>
// To solve the pb of declaration of grammar with locals
#include <typeinfo>

std::ostream& 
   operator<< (std::ostream& os, std::vector<int> const& art)
   {
       os << "[";
       for( auto it = art.begin(); it != art.end() ; it++ ) {
         os << *it << ",";
       }
       os << "]";
       return os;
   }

namespace client
{
   namespace phoenix = boost::phoenix;
   namespace qi = boost::spirit::qi;
   namespace ascii = boost::spirit::ascii;
   using phoenix::val;
   using namespace qi::labels;
   using qi::_val;
   using qi::_1;

   //  Our number list parser
   template <typename Iterator>
   struct mini_wkart_grammar
     // first version: : qi::grammar<Iterator, int(), qi::locals<std::string>, ascii::space_type>
      // second version: : qi::grammar<Iterator, int(), qi::locals<std::string,int>, ascii::space_type>
       : qi::grammar<Iterator, std::vector<int>(), qi::locals<std::string,std::vector<int> >, ascii::space_type>
   {
        mini_wkart_grammar() : mini_wkart_grammar::base_type(start,"numbers")
        {
           using phoenix::push_back;
          // first version: start= (qi::int_ >> qi::char_(',') >> qi::int_)[_val=_1+_3];
          // second version: start= (qi::int_[_b=_1] >> qi::char_(',') >> qi::int_[_b+=_1])[_val=_b];
          start= (qi::int_[push_back(_b,_1)] >> qi::char_(',') >> qi::int_[push_back(_b,_1)])[_val=_b];
          BOOST_SPIRIT_DEBUG_NODE(start);
       }
       // first version OK: qi::rule<Iterator, int(), qi::locals<std::string>, ascii::space_type> start;
       // second version OK: qi::rule<Iterator, int(), qi::locals<std::string,int>, ascii::space_type> start;
       qi::rule<Iterator, std::vector<int>(), qi::locals<std::string,std::vector<int> >, ascii::space_type> start;

    };
}

////////////////////////////////////////////////////////////////////////////
//  Main program
////////////////////////////////////////////////////////////////////////////
int
main()
{
    std::cout << "/////////////////////////////////////////////////////////\n\n";
    std::cout << "\t\tA comma separated list parser for Spirit...\n\n";
    std::cout << "/////////////////////////////////////////////////////////\n\n";

    std::cout << "Give me a comma separated list of numbers.\n";
    std::cout << "Type [q or Q] to quit\n\n";

    // std::string result;
    // first ans second version: int result;
    std::vector<int> result;
    std::string str;
    using boost::spirit::ascii::space;

    client::mini_wkart_grammar<std::string::const_iterator> wkart_grammar;

   while (getline(std::cin, str))
   {
       if (str.empty() || str[0] == 'q' || str[0] == 'Q')
           break;
       std::string::const_iterator iter = str.begin();
       std::string::const_iterator end = str.end();

       // if (client::parse_numbers(str.begin(), str.end()))
       if (boost::spirit::qi::phrase_parse(iter, end, wkart_grammar, space, result))
       {
           std::cout << "-------------------------\n";
           std::cout << "Parsing succeeded\n";
           std::cout << result << " Parses OK: " << std::endl;
       }
       else
{
           std::cout << "-------------------------\n";
           std::cout << "Parsing failed\n";
          std::cout << "-------------------------\n";
      }
   }

   std::cout << "Bye... :-) \n\n";
   return 0;
}

namespace std {
    std::ostream &operator<<(std::ostream &os, vector<int> const &art) {
        os << "[";
        for (auto it = art.begin(); it != art.end(); it++) {
            os << *it << ",";
        }
        os << "]";
        return os;
    }
}

namespace ADL_Hack {
    template <typename T>
    struct allocator : std::allocator<T> { };
}

template <typename T>
using Vector = std::vector<T, ADL_Hack::allocator<T> >;

namespace ADL_Hack {
    template <typename... Ts>
    std::ostream &operator<<(std::ostream &os, std::vector<Ts...> const &art) {
        os << "[";
        for (auto it = art.begin(); it != art.end(); it++) {
            os << *it << ",";
        }
        os << "]";
        return os;
    }
}