C++ 益气

我肯定错过了boost:：recursive_包装器的某些功能，我总是会遇到一个错误：

错误：调用“boost:：tuples:：tuple，std:：allocator>，客户端：：compare\u attr\u op\t，std:：basic\u string，std:：allocator>，boost:：tuples:：null\u类型，boost:：tuples:：null\u类型，boost:：tuples:：null\u类型，boost:：tuples:：null\u类型，boost:：tuples:：null\u类型，boost:：tuples:：tuples:：null\u类型，boost:：tuples:：null\u type>：：tuple（客户端：：表达式\u值&）'

对于语法中定义“表达式”的行：

expression%=attribute_test | boolean_expression

有什么想法吗

namespace client {

    enum compare_attr_op_t {
        cao_eq,
        cao_neq
    };

    enum boolean_op_t {
        bo_and,
        bo_or,
        bo_not
    };

    struct expression_value;

    typedef boost::tuple<std::string, compare_attr_op_t, std::string> attribute_test_value;
    typedef boost::tuple< expression_value, boolean_op_t, expression_value > boolean_expression_value;
    typedef boost::variant< attribute_test_value, boost::recursive_wrapper<boolean_expression_value> > sub_expression_value;

    struct expression_value {
        sub_expression_value value;
    };
}

BOOST_FUSION_ADAPT_STRUCT(
    client::expression_value,
    (client::sub_expression_value, value)
)

namespace client {
    struct compare_attr_ : qi::symbols<char, compare_attr_op_t>
    {
        compare_attr_()
        {
            add
                ("="    , cao_eq)
                ("!="   , cao_neq)
            ;
        }

    } compare_attr;

    struct boolean_op_ : qi::symbols<char, boolean_op_t>
    {
        boolean_op_()
        {
            add
                ("&"    , bo_and)
                ("|"   , bo_or)
            ;
        }

    } boolean_op;


    template <typename Iterator>
    struct attribute_conditions : qi::grammar<Iterator, expression_value(), ascii::space_type>
    {
        attribute_conditions() : attribute_conditions::base_type(expression)
        {
            using qi::eps;
            using qi::lit;
            using qi::_val;
            using qi::lexeme;
            using qi::_1;
            using qi::_2;
            using qi::_3;
            using ascii::char_;
            using ascii::alnum;
            using ascii::alpha;

            expression %= attribute_test | boolean_expression;
            boolean_expression %= expression >> boolean_op >> expression;
            attribute_test %= (attribute_name >> compare_attr >> attribute_value)[std::cout << _1 << ' ' << _2 << ' ' << _3];
            attribute_name %= alpha >> *alnum;
            attribute_value %= lexeme['"' > +(char_ - '"') > '"'];

        }

        qi::rule<Iterator, expression_value(), ascii::space_type> expression;
        qi::rule<Iterator, boolean_expression_value(), ascii::space_type> boolean_expression;
        qi::rule<Iterator, attribute_test_value(), ascii::space_type> attribute_test;
        qi::rule<Iterator, std::string(), ascii::space_type> attribute_name;
        qi::rule<Iterator, std::string(), ascii::space_type> attribute_value;
    };
}

命名空间客户端{
枚举比较属性操作{
曹(音)，
曹涅克
};
枚举布尔运算{
博乌和，
博奥，
伯努诺
};
结构表达式_值；
typedef boost:：元组属性测试值；
typedef boost:：tupleboolean\u expression\u value；
typedef boost:：variantsub_expression_value；
结构表达式\u值{
子表达式值；
};
}
增强融合适应结构(
客户端：：表达式\值，
（客户端：：子表达式值，值）
)
命名空间客户端{
结构比较属性：qi:：符号
{
比较属性
{
添加
（“=”，cao_eq）
（！=，cao_neq）
;
}
}比较属性；
结构布尔运算：qi:：符号
{
布尔函数
{
添加
（“和”，博乌和）
（“|”、bo|或）
;
}
}布尔运算；
模板
结构属性_条件：qi:：grammar
{
属性\条件（）：属性\条件：：基本\类型（表达式）
{
使用qi：：eps；
使用qi：：lit；
使用qi:(u val)；
使用气：词素；
使用气：：_1；
使用气：：_2；
使用气：：_3；
使用ascii:：char；
使用ascii:：alnum；
使用ascii:：alpha；
表达式%=属性|测试|布尔|表达式；
布尔运算表达式%=表达式>>布尔运算>>表达式；
属性测试%=（属性名> COMPAREXATAFR>>属性值）[STD:：CUT< P> >，这是用VisualStudioC++ 2010／Boo1.32.0中的下列内容编写的OK，可能您的编译器无法处理这里的模板。
#include <boost/tuple/tuple.hpp>
#include <boost/spirit/include/qi.hpp>
#include <boost/fusion/adapted.hpp>
using namespace boost::spirit;

#包括
#包括
#包括
使用名称空间boost：：spirit；
<代码> > p>这是用Visual StudioC++ 2010／Boost 1.33.0中包含的内容编译的。可能您的编译器无法处理这里的模板。

#include <boost/tuple/tuple.hpp>
#include <boost/spirit/include/qi.hpp>
#include <boost/fusion/adapted.hpp>
using namespace boost::spirit;

#包括
#包括
#包括
使用名称空间boost：：spirit；
我放弃了这一切，从头开始，给了我这个很好的工作实现：

namespace client {

    enum compare_attr_op_t {
        cao_eq,
        cao_neq
    };

    enum boolean_op_t {
        bo_and,
        bo_or,
        bo_not
    };

    struct expression_value;
    struct or_op_value;
    struct and_expression_value;
    struct and_op_value;
    struct not_op_value;

    typedef boost::tuple<std::string, compare_attr_op_t, std::string> attribute_test_value;
    typedef boost::variant<attribute_test_value, boost::recursive_wrapper<expression_value>, boost::recursive_wrapper<not_op_value> > node_value;

    struct not_op_value {
        boolean_op_t operation;
        node_value rnode;
    };

    struct and_op_value {
        boolean_op_t operation;
        node_value rnode;
    };

    struct and_expression_value {
        node_value lnode;
        std::vector<and_op_value> ops;
    };

    struct or_op_value {
        boolean_op_t operation;
        and_expression_value rnode;
    };

    struct expression_value {
        and_expression_value lnode;
        std::vector<or_op_value> ops;
    };


}

BOOST_FUSION_ADAPT_STRUCT(
        client::not_op_value,
        (client::boolean_op_t, operation)
        (client::node_value, rnode)
)

BOOST_FUSION_ADAPT_STRUCT(
    client::and_expression_value,
    (client::node_value, lnode)
    (std::vector<client::and_op_value>, ops)
)

BOOST_FUSION_ADAPT_STRUCT(
    client::and_op_value,
    (client::boolean_op_t, operation)
    (client::node_value, rnode)
)

BOOST_FUSION_ADAPT_STRUCT(
    client::expression_value,
    (client::and_expression_value, lnode)
    (std::vector<client::or_op_value>, ops)
)

BOOST_FUSION_ADAPT_STRUCT(
    client::or_op_value,
    (client::boolean_op_t, operation)
    (client::and_expression_value, rnode)
)


namespace client {
    struct compare_attr_ : qi::symbols<char, compare_attr_op_t>
    {
        compare_attr_()
        {
            add
                ("="    , cao_eq)
                ("!="   , cao_neq)
            ;
        }

    } compare_attr;

    struct boolean_op_and_t : qi::symbols<char, boolean_op_t>
    {
        boolean_op_and_t()
        {
            add
                ("&"   , bo_and)
                ("and"   , bo_and)
            ;
        }

    } boolean_op_and;

    struct boolean_op_or_t : qi::symbols<char, boolean_op_t>
    {
        boolean_op_or_t()
        {
            add
                ("|"   , bo_or)
                ("or"   , bo_or)
            ;
        }

    } boolean_op_or;

    struct boolean_op_not_t : qi::symbols<char, boolean_op_t>
    {
        boolean_op_not_t()
        {
            add
                ("!"   , bo_not)
                ("not"   , bo_not)
            ;
        }

    } boolean_op_not;

    template <typename Iterator>
    struct attribute_conditions : qi::grammar<Iterator, expression_value(), ascii::space_type>
    {
        attribute_conditions() : attribute_conditions::base_type(expression)
        {
            using qi::eps;
            using qi::lit;
            using qi::_val;
            using qi::lexeme;
            using qi::_1;
            using qi::_2;
            using qi::_3;
            using ascii::char_;
            using ascii::alnum;
            using ascii::alpha;
            using ascii::no_case;

            expression %= and_expression >> *(no_case[boolean_op_or] >> and_expression);
            and_expression %= node >> *(no_case[boolean_op_and] >> node);
            node %= attribute_test | ('(' >> expression >> ')') | not_operation;
            not_operation %= no_case[boolean_op_not] >> node;
            attribute_test %= (attribute_name >> no_case[compare_attr] >> attribute_value);
            attribute_name %= alpha >> *char_("A-Za-z0-9_");
            attribute_value %= lexeme['"' > +(char_ - '"') > '"'];

        }

        qi::rule<Iterator, expression_value(), ascii::space_type> expression;
        qi::rule<Iterator, and_expression_value(), ascii::space_type> and_expression;
        qi::rule<Iterator, not_op_value(), ascii::space_type> not_operation;
        qi::rule<Iterator, node_value(), ascii::space_type> node;
        qi::rule<Iterator, attribute_test_value(), ascii::space_type> attribute_test;
        qi::rule<Iterator, std::string(), ascii::space_type> attribute_name;
        qi::rule<Iterator, std::string(), ascii::space_type> attribute_value;
    };
}

命名空间客户端{
枚举比较属性操作{
曹(音)，
曹涅克
};
枚举布尔运算{
博乌和，
博奥，
伯努诺
};
结构表达式_值；
结构或_op_值；
结构和表达式值；
结构和_op_值；
结构不可用值；
typedef boost:：元组属性测试值；
typedef boost:：变量节点_值；
结构不可用值{
布尔运算；
节点值rnode；
};
结构和_op_值{
布尔运算；
节点值rnode；
};
结构和表达式值{
节点值lnode；
std：：向量运算；
};
结构或_op_值{
布尔运算；
和_表达式_值rnode；
};
结构表达式\u值{
和_表达式_值lnode；
std：：向量运算；
};
}
增强融合适应结构(
客户机：：非op值，
（客户端：：布尔运算，操作）
（客户端：：节点\值，rnode）
)
增强融合适应结构(
客户端：：和表达式值，
（客户端：：节点_值，lnode）
（标准：：矢量，ops）
)
增强融合适应结构(
客户：：和_op_值，
（客户端：：布尔运算，操作）
（客户端：：节点\值，rnode）
)
增强融合适应结构(
客户端：：表达式\值，
（客户端：：和表达式\u值，lnode）
（标准：：矢量，ops）
)
增强融合适应结构(
客户：：或_op_值，
（客户端：：布尔运算，操作）
（客户端：：和表达式值，rnode）
)
命名空间客户端{
结构比较属性：qi:：符号
{
比较属性
{
添加
（“=”，cao_eq）
（！=，cao_neq）
;
}
}比较属性；
结构布尔运算和：qi:：符号
{
布尔运算
{
添加
（“和”，博乌和）
（“和”，bo_和）
;
}
}布尔运算与；
结构布尔值\u op\u或\u t:qi:：符号
{
布尔运算
{
添加
（“|”、bo|或）
（“或”，bo_或）
;
}
}布尔运算；
结构布尔运算非：qi:：符号
{
布尔值
{
添加
（“！”，博乌不是）
（“不”，bo_not）
;
}
}布尔运算不；
模板
结构属性_条件：qi:：grammar
{
属性\条件（）：属性\条件：：基本\类型（表达式）
{
使用qi：：eps；
使用qi：：lit；
使用qi:(u val)；
使用气：词素；
使用气：：_1；
使用气：：_2；
使用气：：_3；
使用ascii:：char；
使用ascii:：alnum；
使用ascii:：alpha；
使用ascii:：no_case；
表达式%=和表达式>>*（无大小写[布尔运算或]>>和表达式）；
和_expression%=node>>*（无_case[boolean_op_and]>>node）；
节点%=属性_测试|（'）（'>>表达式>>