Boost::Variant "Error: no match for call to [...]" on visitor operator overload

Question

我正在尝试实现一个函数以从 AST 从表达式语法传递到字符串，然后测试它是否正确，将它与正确的字符串进行比较。为此，我实现了一个访问者来访问 Boost::Variant 变量并重载了一个名为 "getString" 的函数。

我遇到了很多关于错误定义的错误，我一直在通过 Whosebug 寻找类似的问题，但一切都奏效了。

错误（对访问者的每个重载运算符重复）：

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;
    };
}

Answer 1

您的访问者方法应该是 const:

    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); }

Boost::Variant "Error: no match for call to [...]" on visitor operator overload

Boost::Variant "Error: no match for call to [...]" on visitor operator overload

c++

boost

boost-variant