如何将多态属性与boost::spirit::qi解析器一起使用

Spirit对compiletime多态性更友好

typedef variant<Command1, Command2, Command3> Command;

但是，假设你真的想做老式的多态性。。。

然而，在解析过程中动态地更新多态对象是的一种很好的方法

• 使语法分析器充满语义操作
• 在语法规则的回溯中创建大量内存泄漏
• 使解析速度慢得惊人（因为您有各种各样的动态分配）
• 最糟糕的是，这些都不会被优化掉，即使您实际上没有将属性引用传递到顶级parse API中。（通常，所有属性处理都会在编译时"神奇地"蒸发，这对输入格式验证非常有用）

因此，您需要为基本命令类或派生命令类的对象创建一个holder。使持有者满足RuleOfZero并通过类型擦除获得实际值。

（除了解决"意外"的复杂性和限制w.r.t.内存回收之外，这种抽象的好处是你仍然可以选择静态处理存储，这样你就可以在堆分配中节省[很多]时间。）

我会看看你的样品，看看我是否能很快证明。

以下是我对"holder"类的意思（向CommandBase添加一个虚拟析构函数！）：

struct CommandHolder
{
    template <typename Command> CommandHolder(Command cmd) 
        : storage(new concrete_store<Command>{ std::move(cmd) }) { }
    operator CommandBase&() { return storage->get(); }
  private:
    struct base_store {
        virtual ~base_store() {}; 
        virtual CommandBase& get() = 0;
    };
    template <typename T> struct concrete_store : base_store {
        concrete_store(T v) : wrapped(std::move(v)) { }
        virtual CommandBase& get() { return wrapped; }
      private:
        T wrapped; 
    };
    boost::shared_ptr<base_store> storage;
};

正如您所看到的，为了简化所有权语义，我选择了unique_ptr（variant将避免一些分配开销，作为稍后的优化）。我无法让unique_ptr与Spirit一起工作，因为Spirit根本没有移动意识。（Spirit X3将是）。

我们可以基于这个持有者简单地实现类型的擦除AnyCommand：

struct AnyCommand : CommandBase
{
    template <typename Command> AnyCommand(Command cmd) 
        : holder(std::move(cmd)) { }
    virtual void commandAction() override { 
        static_cast<CommandBase&>(holder).commandAction();
    }
  private:
    CommandHolder holder;
};

因此，现在您可以将任何命令"分配"给AnyCommand，并通过holder"多态地"使用它，即使holder和AnyCommand具有完美的值语义。

这个示例语法可以：

CommandParser() : CommandParser::base_type(commands)
{
    using namespace qi;
    CommandARule = int_    >> int_           >> "CMD_A";
    CommandBRule = double_ >> lexeme[+(char_ - space)] >> "CMD_B";
    CommandCRule = ':' >> lexeme [+graph - ';'] >> commands >> ';';
    command  = CommandARule | CommandBRule | CommandCRule;
    commands = +command;
}

规则定义为：

qi::rule<Iterator, CommandTypeA(),            Skipper> CommandARule;
qi::rule<Iterator, CommandTypeB(),            Skipper> CommandBRule;
qi::rule<Iterator, CommandTypeC(),            Skipper> CommandCRule;
qi::rule<Iterator, AnyCommand(),              Skipper> command;
qi::rule<Iterator, std::vector<AnyCommand>(), Skipper> commands;

这是一个非常令人愉快的值语义和运行时多态性的组合：）

的测试主体

int main()
{
    std::string const input =
        ":group             n"
        "     3.14  π CMD_B n"
        "     -42  42 CMD_A n"
        "     -inf -∞ CMD_B n"
        "     +inf +∞ CMD_B n"
        ";                  n"
        "99 0 CMD_A";
    auto f(begin(input)), l(end(input));
    std::vector<AnyCommand> commandList;
    CommandParser<std::string::const_iterator> p;
    bool success = qi::phrase_parse(f, l, p, qi::space, commandList);
    if (success) {
        BOOST_FOREACH(AnyCommand& c, commandList) {
            c.commandAction();
        }
    } else {
        std::cout << "Parsing failedn";
    }
    if (f!=l) {
        std::cout << "Remaining unparsed input '" << std::string(f,l) << "'n";
    }
}

打印：

Subroutine: group has 4 commands:
CommandType B! valueA: 3.14 string: π
CommandType A! ValueA: -42 ValueB: 42
CommandType B! valueA: -inf string: -∞
CommandType B! valueA: inf string: +∞
CommandType A! ValueA: 99 ValueB: 0

全部查看在Coliru上直播