Boost::Variant "Error: no match for call to [...]" 访问者操作符重载

Posted 2023-02-21

【中文标题】Boost::Variant "Error: no match for call to [...]" 访问者操作符重载

【英文标题】：Boost::Variant "Error: no match for call to [...]" on visitor operator overload

【发布时间】：2019-05-14 09:19:51

【问题描述】：

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

我收到很多关于错误定义的错误，我一直在通过 *** 寻找类似的问题，但一切正常。

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

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&'

打印机.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】：

你的访问者方法应该是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); 

【讨论】：

谢谢！它解决了这个问题。您是如何从我提供的错误消息中获得该解决方案的？我以为我已经尝试过了，但也许我确实将 const 放在声明的开头（在 std::string 之前）。

我查看了 boost 文档，发现他们的方法在他们的访问者示例中被声明为 const。然后我在一个在线编译器（Wandbox）中测试了我的理论。将const 放在我所做的位置告诉编译器这些方法不会更改visitor 对象。