C++ 嵌套boost:：variant的分段错误

以下程序已从原始程序缩减。当它运行时，我遇到了一个分段错误。如果我用

算术表达式

删除第24行，则程序不再崩溃。如何消除分割错误

#include <boost/config/warning_disable.hpp>
#include <boost/spirit/home/x3.hpp>
#include <boost/spirit/home/x3/support/ast/variant.hpp>
#include <boost/spirit/include/qi_expect.hpp>
#include <boost/spirit/home/x3/directive/expect.hpp>

#include <iostream>
#include <string>

namespace wctl_parser {

namespace x3 = boost::spirit::x3;
namespace ascii = x3::ascii;
namespace qi = boost::spirit::qi;

using x3::ulong_;
using x3::lexeme;

//--- Ast structures
struct ArithmeticUnaryExpression;
using AtomicProp = std::string;

using ArithmeticExpression = x3::variant<
    x3::forward_ast<ArithmeticUnaryExpression>,
    unsigned long
>;

struct ArithmeticUnaryExpression {
    std::string op;
    ArithmeticExpression operand;
};

using Expression = x3::variant<
    ArithmeticExpression
>;

template <typename T> auto rule = [](const char* name = typeid(T).name()) {
    struct _{};
    return x3::rule<_, T> {name};
};

template <typename T> auto as = [](auto p) { return rule<T>() = p; };

//--- Rules

x3::rule<struct aTrivRule, ArithmeticExpression> aTriv("aTriv");
x3::rule<struct exprRule, Expression> expr("expression");

auto const aTriv_def = rule<ArithmeticExpression>("aTriv")
    = ulong_
//  | '(' > expr > ')'
    ;

auto const primitive = rule<Expression>("primitive")
    = aTriv
    ;

auto const expr_def
    = primitive
    ;

BOOST_SPIRIT_DEFINE(aTriv)
BOOST_SPIRIT_DEFINE(expr)

auto const entry = x3::skip(ascii::space) [expr];

} //End namespace

int main() {

    std::string str("prop");
    namespace x3 = boost::spirit::x3;   
    wctl_parser::Expression root;
    auto iter = str.begin();
    auto end = str.end();
    bool r = false;
    r = parse(iter, end, wctl_parser::entry, root);
    if (r) {
        std::cout << "Parses OK:" << std::endl << str << std::endl;
        if (iter != end) std::cout << "Partial match" << std::endl;
        std::cout << std::endl << "----------------------------\n";
    }
    else {
        std::cout << "!! Parsing failed:" << std::endl << str << std::endl << std::endl << "----------------------------\n";
    }
    return 0;
}

#包括
#包括
#包括
#包括
#包括
#包括
#包括
名称空间wctl_解析器{
名称空间x3=boost:：spirit:：x3；
名称空间ascii=x3:：ascii；
名称空间qi=boost:：spirit:：qi；
使用x3:：ulong_2;；
使用x3：：词素；
//---Ast结构
结构算术表达式；
使用AtomicProp=std:：string；
使用算术表达式=x3:：variant<
x3：：向前，
无符号长
>;
结构算术表达式{
std：：字符串op；
算术表达式操作数；
};
使用Expression=x3:：variant<
算术表达式
>;
模板自动规则=[]（常量字符*名称=类型ID（T）.name（））{
结构{}；
返回x3:：规则{name}；
};
模板auto-as=[]（auto p）{return rule（）=p；}；
//---规则
x3：：规则aTriv（“aTriv”）；
x3:：规则表达式（“表达式”）；
自动约束定义=规则（“aTriv”）
=乌龙_
//|'（'>expr>）'
;
自动常量原语=规则（“原语”）
=心房
;
自动常数表达式
=原语
;
提升精神定义（aTriv）
提升精神定义（expr）
auto const entry=x3:：skip（ascii:：space）[expr]；
}//结束命名空间
int main（）{
std：：字符串str（“prop”）；
名称空间x3=boost:：spirit:：x3；
wctl_解析器：：表达式根；
自动iter=str.begin（）；
自动结束=str.end（）；
布尔r=假；
r=parse（iter，end，wctl_parser:：entry，root）；
if（r）{
std：：cout您的变体

using ArithmeticExpression = x3::variant<
    x3::forward_ast<ArithmeticUnaryExpression>,
    unsigned long
>;

using ArithmeticExpression = x3::variant<
    unsigned long,
    x3::forward_ast<ArithmeticUnaryExpression>
>;