这是一个工作示范希望您可以使用它作为参考,以弄清楚您的代码有什么问题：

///// grammar implementation /////
#include <boost/fusion/include/vector10.hpp>
#include <boost/spirit/include/qi_bool.hpp>
#include <boost/spirit/include/qi_char_.hpp>
#include <boost/spirit/include/qi_grammar.hpp>
#include <boost/spirit/include/qi_operator.hpp>
#include <boost/spirit/include/qi_rule.hpp>
#include <boost/spirit/include/qi_string.hpp>

struct FourBools : boost::spirit::qi::grammar<
    char const*,bool> attribute_type;

    FourBools() : base_type(start_)
    {
        using boost::spirit::bool_;

        start_
            =   "4bools:"
                >> bool_ >> ','
                >> bool_ >> ','
                >> bool_ >> ';'
            ;
    }

private:
    boost::spirit::qi::rule<
        base_type::iterator_type,base_type::sig_type
    > start_;
};
FourBools const fourBools;


///// demonstration of use /////
#include <string>
#include <ios>
#include <iostream>
#include <boost/fusion/include/at_c.hpp>
#include <boost/spirit/include/phoenix_bind.hpp>
#include <boost/spirit/include/phoenix_core.hpp>
#include <boost/spirit/include/qi_action.hpp>
#include <boost/spirit/include/qi_parse.hpp>

typedef FourBools::attribute_type attr_t;

struct verify_same
{
    explicit verify_same(attr_t const& expected) : expected_(expected) { }

    void verify(attr_t const& actual) const
    {
        using boost::fusion::at_c;

        std::cout << std::boolalpha
            << "same as expected: " << (actual == expected_)
            << "\nactual values: "
            << at_c<0>(actual) << ' '
            << at_c<1>(actual) << ' '
            << at_c<2>(actual) << ' '
            << at_c<3>(actual) << '\n';
    }

private:
    attr_t expected_;
};

int main()
{
    namespace phx = boost::phoenix;
    namespace spirit = boost::spirit;

    std::string const input("4bools:true,false;");
    verify_same const vs(attr_t(true,false));

    char const* first = input.c_str();
    char const* const last = first + input.size();
    bool const success = spirit::qi::parse(
        first,fourBools[phx::bind(&verify_same::verify,phx::cref(vs),spirit::_1)]
    );
    if (!success)
        std::cout << "parse() Failed\n";
    else if (first != last)
        std::cout << "didn't consume all input\n";
    std::cout.flush();
}

除此之外,我认为使用纯均匀类型的元组是奇怪的;个人来说,我会将语法的合成属性更改为boost :: array< bool,4>.

编辑(响应OP的编辑)：有好消息和坏消息,更好的消息.

这是一个好消息：Boost.Fusion具有使用最少代码完成所需功能的功能：boost::fusion::fused<>.这将需要一个可调用类型(包括自由功能指针和成员函数指针),它可以接受多个参数并将该可调用类型包装一个融合序列的函子;当调用该函子时,它需要Fusion序列并解包它,将元组的各个元素转发到包装的可调用类型作为单独的参数.

所以,考虑到我已经发布的语法和以下内容：

#include <string>
#include <ios>
#include <iostream>
#include <boost/fusion/include/at_c.hpp>
#include <boost/fusion/include/make_fused.hpp>
#include <boost/spirit/include/phoenix_bind.hpp>
#include <boost/spirit/include/phoenix_core.hpp>
#include <boost/spirit/include/phoenix_fusion.hpp>
#include <boost/spirit/include/qi_action.hpp>
#include <boost/spirit/include/qi_parse.hpp>

typedef FourBools::attribute_type attr_t;

void free_func_taking_tuple(attr_t const& tup)
{
    using boost::fusion::at_c;

    std::cout << std::boolalpha
        << "inside free_func_taking_tuple() :: "
        << at_c<0>(tup) << ' '
        << at_c<1>(tup) << ' '
        << at_c<2>(tup) << ' '
        << at_c<3>(tup) << '\n';
}

void free_func_taking_bools(
    bool const a,bool const b,bool const c,bool const d
)
{
    std::cout << std::boolalpha
        << "inside free_func_taking_bools() :: "
        << a << ' '
        << b << ' '
        << c << ' '
        << d << '\n';
}

boost :: spirit :: qi :: parse()可以这样调用：

namespace phx = boost::phoenix;
namespace spirit = boost::spirit;
using boost::fusion::make_fused;

// calls free_func_taking_tuple,nothing new here
spirit::qi::parse(
    first,fourBools[phx::bind(free_func_taking_tuple,spirit::_1)]
);

// calls free_func_taking_bools,using boost::fusion::fused<> to unpack the tuple
// into separate arguments
spirit::qi::parse(
    first,fourBools[phx::bind(make_fused(&free_func_taking_bools),spirit::_1)]
);

这是一个坏消息：Boost.Fusion的可调用类型包装器依赖于TR1 / C 11 result_of协议,而Boost.Phoenix v2实现了Boost.Lambda result_of协议 – 这些不兼容.因此,您必须自己解压元组元素：

namespace phx = boost::phoenix;
namespace spirit = boost::spirit;

spirit::qi::parse(
    first,fourBools[phx::bind(
        free_func_taking_bools,phx::at_c<0>(spirit::_1),phx::at_c<1>(spirit::_1),phx::at_c<2>(spirit::_1),phx::at_c<3>(spirit::_1)
    )]
);

呸！但是,还有一个好消息：Boost.Phoenix v3将在Boost 1.47中发布,它实现了TR1 / C11的result_of协议.因此,从Boost 1.47开始,您将可以使用boost :: fusion :: fused&并节省自己一些繁琐的样板.