在编译时对已知N的std::元组重复

您可以在这里看到x3::repeat(3)[x3::float_]的合成属性是一个vector<float>，它不匹配您的属性(基本上是一个大小为3的融合序列)。请注意，合成属性不依赖于您传递的值。

为了得到你想要的，你需要另一个指令，它的类型依赖于你传递的值。然后，该指令将生成一个序列，其中它的主题被重复N次(简单地将工作"委托"给x3::sequence将确保在属性传播方面一切正常工作)。我能想到至少两种方法:repeat<N>[parser]或repeat(integral_constant<int,N>)[parser]之类的东西。在下面的代码中，我选择了第二种方法，使用boost::hana::integral_constant，它允许您使用:

custom::repeat(3_c)[ x3::float_ >> (' ' | x3::eol | x3::eoi) ]

完整代码(在WandBox上运行)

custom_repeat.hpp

#include <type_traits>
#include <boost/spirit/home/x3.hpp> 
namespace custom
{
    struct repeat_gen
    {
        template <int Size>
        struct repeat_gen_lvl1
        {
            //using overloads with integral constants to avoid needing to partially specialize a function
            //this actually builds the sequence of parsers
            template <typename Parser,int N>
            auto generate_sequence(Parser const& parser, std::integral_constant<int,N>) const
            {
                return generate_sequence(parser,std::integral_constant<int,N-1>{}) >> parser;
            }
            template <typename Parser>
            auto generate_sequence(Parser const parser,std::integral_constant<int,1>) const
            {
                return parser;
            }
            template<typename Subject>
            auto operator[](Subject const& subject) const
            {
                //here the actual sequence is generated
                return generate_sequence(boost::spirit::x3::as_parser(subject), std::integral_constant<int,Size>{});
            }
        };
        template <typename IntConstant>
        repeat_gen_lvl1<int(IntConstant::value)>
        operator()(IntConstant) const
        {
            //returns an object that know the size of the wanted sequence and has an operator[] that will capture the subject
            return {};
        }
        template <typename IntegerType, typename Enable=std::enable_if_t<std::is_integral<IntegerType>::value> >
        auto operator()(IntegerType n) const
        {
            return boost::spirit::x3::repeat(n);
        }
    };
    //this object's only purpose is having an operator()
    auto const repeat = repeat_gen{};
}

main.cpp

#include <iostream>
#include <boost/spirit/home/x3.hpp>
#include <boost/fusion/include/std_tuple.hpp>
#include <boost/fusion/include/std_pair.hpp>
#include <boost/fusion/include/adapt_struct.hpp>
#include <boost/fusion/include/io.hpp>
#include <boost/fusion/include/as_vector.hpp>
#include <boost/fusion/include/is_sequence.hpp>
#include <boost/hana/integral_constant.hpp>
#include <boost/mpl/int.hpp>
#include "custom_repeat.hpp"
namespace x3 = boost::spirit::x3;
using namespace boost::hana::literals;
template <typename T>
void print_attr(const std::vector<T>& vec)
{
    std::cout << "Vector: ";
    for(const auto& elem : vec)
        std::cout << "[" << elem << "]";
}
template <typename Sequence, typename Enable=std::enable_if_t<boost::fusion::traits::is_sequence<Sequence>::value> >
void print_attr(const Sequence& seq)
{
    std::cout << "Sequence: " << boost::fusion::as_vector(seq);
}
template <typename Attr,typename Parser>
void parse(const std::string& str, const Parser& parser)
{
    Attr attr;
    std::string::const_iterator iter = std::begin(str), end = std::end(str);
    bool ret = x3::parse(iter, end, parser, attr);
    if(ret && (iter==end))
    {
        std::cout << "Success.n";
        print_attr(attr);
        std::cout << std::endl;
    }
    else
    {
        std::cout << "Something failed. Unparsed: ->|" << std::string(iter,end) << "|<-" << std::endl;
    }
}
struct float_holder
{
    float val;
};
BOOST_FUSION_ADAPT_STRUCT(float_holder,val);
int main()
{
    boost::mpl::int_<2> two;
    std::integral_constant<int,1> one;
    parse<std::tuple<float,float,float> >("0.3 0.2 0.1", custom::repeat(3_c)[ x3::float_ >> (' ' | x3::eol | x3::eoi) ] );
    parse<std::pair<float,float> >("0.2 0.1", custom::repeat(two)[ x3::float_ >> (' ' | x3::eol | x3::eoi) ] );
    parse<float_holder>("0.1", custom::repeat(one)[ x3::float_ >> (' ' | x3::eol | x3::eoi) ] );
    parse<std::vector<float> >("0.3 0.2 0.1", custom::repeat(3)[ x3::float_ >> (' ' | x3::eol | x3::eoi) ] );
}