Boost :: Variant «Ошибка: нет совпадения для вызова […]» при перегрузке оператора посетителя

Я пытаюсь реализовать функцию для передачи из AST из грамматики выражения в строку, а затем проверить правильность сравнения ее с правильной строкой. Для этого я реализовал посетителя для посещения переменной Boost :: Variant и перегрузил функцию с именем «getString».

Я получаю много ошибок о неправильных определениях, и я искал StackOverflow для похожих проблем, но все работало.

Ошибки (повторяются для каждого из перегруженных операторов на посетителя):

In file included from /usr/include/boost/spirit/home/support/info.hpp:14,
                 from /usr/include/boost/spirit/home/qi/domain.hpp:16,
                 from /usr/include/boost/spirit/home/qi/meta_compiler.hpp:15,
                 from /usr/include/boost/spirit/home/qi/action/action.hpp:14,
                 from /usr/include/boost/spirit/home/qi/action.hpp:14,
                 from /usr/include/boost/spirit/home/qi.hpp:14,
                 from /usr/include/boost/spirit/include/qi.hpp:16,
                 from src/./Expression.cpp:2,
                 from src/main.cpp:1:
/usr/include/boost/variant/variant.hpp: In instantiation of 'boost::detail::variant::invoke_visitor<Visitor>::result_type boost::detail::variant::invoke_visitor<Visitor>::internal_visit(T&, int) [with T = std::basic_string<char>; Visitor = const testing::visitor; boost::detail::variant::invoke_visitor<Visitor>::result_type = std::basic_string<char>]':
/usr/include/boost/variant/detail/visitation_impl.hpp:114:9:   required from 'typename Visitor::result_type boost::detail::variant::visitation_impl_invoke_impl(int, Visitor&, VoidPtrCV, T*, mpl_::true_) [with Visitor = boost::detail::variant::invoke_visitor<const testing::visitor>; VoidPtrCV = void*; T = std::basic_string<char>; typename Visitor::result_type = std::basic_string<char>; mpl_::true_ = mpl_::bool_<true>]'
/usr/include/boost/variant/detail/visitation_impl.hpp:154:41:   required from 'typename Visitor::result_type boost::detail::variant::visitation_impl_invoke(int, Visitor&, VoidPtrCV, T*, NoBackupFlag, int) [with Visitor = boost::detail::variant::invoke_visitor<const testing::visitor>; VoidPtrCV = void*; T = std::basic_string<char>; NoBackupFlag = boost::variant<std::basic_string<char>, double, bool, boost::recursive_wrapper<ast::unary>, boost::recursive_wrapper<ast::expression> >::has_fallback_type_; typename Visitor::result_type = std::basic_string<char>]'
/usr/include/boost/variant/detail/visitation_impl.hpp:238:5:   required from 'typename Visitor::result_type boost::detail::variant::visitation_impl(int, int, Visitor&, VoidPtrCV, mpl_::false_, NoBackupFlag, Which*, step0*) [with Which = mpl_::int_<0>; step0 = boost::detail::variant::visitation_impl_step<boost::mpl::l_iter<boost::mpl::l_item<mpl_::long_<5>, std::basic_string<char>, boost::mpl::l_item<mpl_::long_<4>, double, boost::mpl::l_item<mpl_::long_<3>, bool, boost::mpl::l_item<mpl_::long_<2>, boost::recursive_wrapper<ast::unary>, boost::mpl::l_item<mpl_::long_<1>, boost::recursive_wrapper<ast::expression>, boost::mpl::l_end> > > > > >, boost::mpl::l_iter<boost::mpl::l_end> >; Visitor = boost::detail::variant::invoke_visitor<const testing::visitor>; VoidPtrCV = void*; NoBackupFlag = boost::variant<std::basic_string<char>, double, bool, boost::recursive_wrapper<ast::unary>, boost::recursive_wrapper<ast::expression> >::has_fallback_type_; typename Visitor::result_type = std::basic_string<char>; mpl_::false_ = mpl_::bool_<false>]'
/usr/include/boost/variant/variant.hpp:2384:48:   required from 'static typename Visitor::result_type boost::variant<T0, TN>::internal_apply_visitor_impl(int, int, Visitor&, VoidPtrCV) [with Visitor = boost::detail::variant::invoke_visitor<const testing::visitor>; VoidPtrCV = void*; T0_ = std::basic_string<char>; TN = {double, bool, boost::recursive_wrapper<ast::unary>, boost::recursive_wrapper<ast::expression>}; typename Visitor::result_type = std::basic_string<char>]'
/usr/include/boost/variant/variant.hpp:2398:43:   required from 'typename Visitor::result_type boost::variant<T0, TN>::internal_apply_visitor(Visitor&) [with Visitor = boost::detail::variant::invoke_visitor<const testing::visitor>; T0_ = std::basic_string<char>; TN = {double, bool, boost::recursive_wrapper<ast::unary>, boost::recursive_wrapper<ast::expression>}; typename Visitor::result_type = std::basic_string<char>]'
/usr/include/boost/variant/variant.hpp:2423:52:   required from 'typename Visitor::result_type boost::variant<T0, TN>::apply_visitor(Visitor&) [with Visitor = const testing::visitor; T0_ = std::basic_string<char>; TN = {double, bool, boost::recursive_wrapper<ast::unary>, boost::recursive_wrapper<ast::expression>}; typename Visitor::result_type = std::basic_string<char>]'
/usr/include/boost/variant/detail/apply_visitor_unary.hpp:84:43:   required from 'typename Visitor::result_type boost::apply_visitor(const Visitor&, Visitable&) [with Visitor = testing::visitor; Visitable = boost::variant<std::basic_string<char>, double, bool, boost::recursive_wrapper<ast::unary>, boost::recursive_wrapper<ast::expression> >; typename Visitor::result_type = std::basic_string<char>]'
src/./Printer.cpp:29:64:   required from here
/usr/include/boost/variant/variant.hpp:1046:24: error: no match for call to '(const testing::visitor) (std::basic_string<char>&)'
         return visitor_(operand);
                ~~~~~~~~^~~~~~~~~
In file included from src/main.cpp:2:
src/./Printer.cpp:20:21: note: candidate: 'std::string testing::visitor::operator()(std::string&)' <near match>
         std::string operator()(std::string& v)        { return v; }
                     ^~~~~~~~
src/./Printer.cpp:20:21: note:   passing 'const testing::visitor*' as 'this' argument discards qualifiers
src/./Printer.cpp:21:21: note: candidate: 'std::string testing::visitor::operator()(double&)'
         std::string operator()(double& v)             { return boost::lexical_cast<std::string>(v); }
                     ^~~~~~~~
src/./Printer.cpp:21:21: note:   no known conversion for argument 1 from 'std::basic_string<char>' to 'double&'
src/./Printer.cpp:22:21: note: candidate: 'std::string testing::visitor::operator()(bool&)'
         std::string operator()(bool& b)               { return b ? "True" : "False"; }
                     ^~~~~~~~
src/./Printer.cpp:22:21: note:   no known conversion for argument 1 from 'std::basic_string<char>' to 'bool&'
src/./Printer.cpp:24:21: note: candidate: 'std::string testing::visitor::operator()(ast::expression&)'
         std::string operator()(ast::expression& e)    { return getString(e); }
                     ^~~~~~~~
src/./Printer.cpp:24:21: note:   no known conversion for argument 1 from 'std::basic_string<char>' to 'ast::expression&'
src/./Printer.cpp:25:21: note: candidate: 'std::string testing::visitor::operator()(ast::unary&)'
         std::string operator()(ast::unary& e)         { return getString(e); }
                     ^~~~~~~~
src/./Printer.cpp:25:21: note:   no known conversion for argument 1 from 'std::basic_string<char>' to 'ast::unary&'

Printer.cpp:

 #include <boost/lexical_cast.hpp> #include <boost/spirit/include/qi.hpp> #include <boost/spirit/include/phoenix.hpp> #include <boost/spirit/include/phoenix_operator.hpp> #include <boost/variant/recursive_wrapper.hpp> #include <string> #include "AST.hpp" namespace testing { std::string getString(ast::expression& e); std::string getString(ast::operation& op); std::string getString(ast::unary& op); std::string getString(ast::optoken& opt); struct visitor : boost::static_visitor<std::string> { std::string operator()(std::string& v) { return v; } std::string operator()(double& v) { return boost::lexical_cast<std::string>(v); } std::string operator()(bool& b) { return b ? "True" : "False"; } std::string operator()(ast::expression& e) { return getString(e); } std::string operator()(ast::unary& e) { return getString(e); } }; std::string getString(ast::expression& e) { std::string s = boost::apply_visitor(visitor(), e.first); std::string result = "( " + s; for (auto it = e.rest.begin(); it != e.rest.end(); ++it) { result += getString(*it); } result += " )"; return result; } std::string getString(ast::unary& op) { std::string s = boost::apply_visitor(visitor(), op.operand_); return " " + getString(op.operator_) + " " + s; } std::string getString(ast::operation& op) { std::string s = boost::apply_visitor(visitor(), op.operand_); return " " + getString(op.operator_) + " " + s; } std::string getString(ast::optoken& opt) { switch(opt) { case ast::op_plus: return "+"; case ast::op_minus: return "-"; case ast::op_times: return "*"; case ast::op_divide: return "/"; case ast::op_not: return "!"; case ast::op_equal: return "=="; case ast::op_not_equal: return "!="; case ast::op_less: return "<"; case ast::op_less_equal: return "<="; case ast::op_greater: return ">"; case ast::op_greater_equal: return ">="; case ast::op_and: return "&&"; case ast::op_or: return "||"; } return "undf"; } } 

AST.hpp

 namespace ast { struct unary; struct expression; typedef boost::variant< std::string, double, bool, boost::recursive_wrapper<unary>, boost::recursive_wrapper<expression> > operand; enum optoken { op_plus, op_minus, op_times, op_divide, op_positive, op_negative, op_not, op_equal, op_not_equal, op_less, op_less_equal, op_greater, op_greater_equal, op_and, op_or }; struct operation { optoken operator_; operand operand_; }; struct unary { optoken operator_; operand operand_; }; struct expression { operand first; std::list<operation> rest; }; } 

Всего 1 ответ


Ваши методы посетителя должны быть постоянными:

    std::string operator()(std::string& v) const { return v; }
    std::string operator()(double& v) const { return boost::lexical_cast<std::string>(v); }
    std::string operator()(bool& b) const { return b ? "True" : "False"; }

    std::string operator()(ast::expression& e) const { return getString(e); }
    std::string operator()(ast::unary& e) const { return getString(e); }

Есть идеи?

10000