在 Boost.Spirit 中，为什么向量(包裹在结构中）需要融合包装器，而不是变体?

我想了解使用 Boost.Spirit 封装struct时需要BOOST_FUSION_ADAPT_STRUCT的确切场景。

下面是两个例子。 一个例子是(仅)具有variant数据成员的单成员struct。 此版本不需要将结构包装在 Fusion 容器中的BOOST_FUSION_ADAPT_STRUCT宏。 构造函数足以让 Spirit 根据传入的 rhs 实例化/填充属性。

(请参阅代码中的注释，以了解我认为由于属性折叠规则而导致的 Boost.Spirit 为规则定义的 rhs 生成的属性类型。

第二个示例是(仅)具有vector数据成员的单成员struct。 即使构造函数定义为允许 Spirit 基于 rhs 填充属性，它也无法在没有BOOST_FUSION_ADAPT_STRUCT的情况下编译。

为什么会有差异？我想了解为什么在第一种情况下，可以使用构造函数来填充属性(struct)，而在第二种情况下，构造函数是不够的，必须使用BOOST_FUSION_ADAPT_STRUCT。

上面提到的例子如下。

示例 1：变体

#include <string>
#include <vector>
#include <boost/variant.hpp>
#include <boost/spirit/include/qi.hpp>
namespace qi  = boost::spirit::qi;
typedef std::string::const_iterator It;
using intermediate = boost::variant<std::string, int>;
// Simple parser demonstrating successful build with 'works_great'
struct works_great // No need for BOOST_FUSION_ADAPT_STRUCT - whoopee!
// But why - even given the constructor??
{
intermediate i;
works_great() = default;
works_great(intermediate i) : i{i} {}
};
// Not required for 'works_great' - constructors work just fine
//BOOST_FUSION_ADAPT_STRUCT(works_great, v)
struct parser : qi::grammar<It, works_great()>
{
parser() : parser::base_type(works_great)
{
using namespace qi;
intermediate = qi::string("test") | qi::int_;
// rhs should have attribute of type 'variant',
// matching the constructor
works_great = '{' >> intermediate >> '}';
}
private:
qi::rule<It, intermediate()>  intermediate;
qi::rule<It, works_great()>   works_great;
};
int main()
{
// The following all compiles/builds just fine
// (I don't care about the actual runtime results).
static const parser p;
works_great wg;
std::string const data {"{test}"};
auto f(begin(data)), l(end(data));
qi::parse(f,l,p,wg);
}

示例 2：矢量

#include <string>
#include <vector>
#include <boost/variant.hpp>
#include <boost/spirit/include/qi.hpp>
namespace qi  = boost::spirit::qi;
typedef std::string::const_iterator It;
// We need BOOST_FUSION_ADAPT_STRUCT for this one, but not for the above.
// Constructors don't help. Only difference seems to be
// the vector (rather than variant).
struct not_so_much // not so much - unless BOOST_FUSION_ADAPT_STRUCT is used
{
std::vector<int> s;
// Constructors do not help here
//not_so_much() = default;
//not_so_much(std::vector<int> s) : s{std::move(s)} {}
};
// Required for 'not_so_much' - constructors don't work
BOOST_FUSION_ADAPT_STRUCT(not_so_much, s)
// Simple parser demonstrating successful build with 'not_so_much' -
// but only when BOOST_FUSION_ADAPT_STRUCT is used.
struct parser : qi::grammar<It, not_so_much()>
{
parser() : parser::base_type(not_so_much)
{
using namespace qi;
// Note: I know that 'eps' is required, below, to compile the 
// single-member struct successfully
// rhs should have attribute of type 'vector<int>',
// matching the constructor as well...
// but it doesn't work.
not_so_much = eps >> (qi::int_ % "|");
}
private:
qi::rule<It, not_so_much()> not_so_much;
};
int main()
{
// The following all compiles/builds just fine
static const parser p;
not_so_much nm;
std::string const data {"5|9|16"};
auto f(begin(data)), l(end(data));
qi::parse(f,l,p,nm);
}