语义操作后丢弃解析结果

Question

在 Boost.Spirit 中，只需执行以下操作即可从流中读取到 std::vector：

#include<vector>
#include<boost/spirit/include/qi.hpp>
namespace sqi = boost::spirit::qi;
int main(){
        std::string const v_str = "AA BB CC";
        std::vector<std::string> v;
        auto it = begin(v_str);
        bool r = sqi::phrase_parse(it, end(v_str), 
                    (*sqi::lexeme[+sqi::char_("A-Z")]), sqi::space, v);
        assert( v.size() == 3  and v[2] == "CC" );
}

但是，由于输入格式的原因，我提前知道了元素的数量，并且我应该能够在向量中保留空间。 例如输入字符串为“3 AA BB CC”，可以预先分配三个元素。

问题是如何将这些额外信息传递给向量并优化后面的push_back（例如避免重新分配）。

我尝试的是在开始时解析一个整数，将语义操作与执行reserve 的位置相关联。

        std::string const v_str = "3 AA BB CC";
        std::vector<std::string> v;
        auto it = begin(v_str);
        bool r = sqi::phrase_parse(it, end(v_str), 
             sqi::int_[([&](int i){v.reserve(i);})] >> 
                (*sqi::lexeme[+sqi::char_("A-Z")]), sqi::space, v);

问题是在语义操作之后整数没有被忽略，从我的测试中我可以看到它试图在保留后将结果（示例中的3）推送到向量中。

另一种解决方法是向 phrase_parse 函数添加另一个参数，但这似乎有点过头了。

那么，如何在 Boost.Spirit 中解析某些内容，只执行语义操作而不将结果发送到 sink 变量？

即使可以做到这一点，我也不确定这是否是正确的方法。

Answer 1

您可以创建在插​​入和解析相同文本两次时仅计算在内的假向量：

#include<vector>
#include<boost/spirit/include/qi.hpp>
namespace sqi = boost::spirit::qi;
struct fake_vector
{
    typedef std::string value_type;
    fake_vector() : counter(0) {}
    std::size_t end() const {return 0;};
    void insert(std::size_t, std::string){ ++counter; }

    std::size_t counter;
};
int main(){
        std::string const v_str = "AA BB CC";
        auto it = begin(v_str);
        fake_vector fv;
        bool r = sqi::phrase_parse(it, end(v_str), (*sqi::lexeme[+sqi::char_("A-Z")]), sqi::space, fv);
        assert(fv.counter == 3);
        std::vector<std::string> v;
        v.reserve(fv.counter);
        it = begin(v_str);
        r = sqi::phrase_parse(it, end(v_str), (*sqi::lexeme[+sqi::char_("A-Z")]), sqi::space, v);
        assert( v.size() == 3  and v[2] == "CC" );
}

Answer 2

好吧，我似乎不得不解构 Spirit 的简单设施并将所有转换为语义动作，这在途中产生了其他问题（例如，lexeme[+char_] 映射到 std::vector<char> 而不是被执行的 std::string .

{
    std::string const v_str = "AA BB CC";
    std::vector<std::string> v;
    auto it = begin(v_str);
    bool r = sqi::phrase_parse(it, end(v_str), 
        (*(sqi::lexeme[(+sqi::char_("A-Z"))][([&](auto&& s){v.emplace_back(begin(s), end(s));})])), sqi::space);
    assert( v.size() == 3);
    assert( v[2] == "CC" );
}
{
    std::string const v_str = "3 AA BB CC";
    std::vector<std::string> v;
    auto it = begin(v_str);
    bool r = sqi::phrase_parse(it, end(v_str), 
        sqi::int_[([&](int i){v.reserve(i);})] >> 
            (*(sqi::lexeme[(+sqi::char_("A-Z"))][([&](auto&& s){v.emplace_back(begin(s), end(s));})])), sqi::space);
    assert( v.size() == 3 );
    assert( v[2] == "CC" );
}

由于这修改了phrase_parse 的最后一个参数，我不妨放一个虚拟的int。

Answer 3

感谢@sehe 和@drus 指向我的链接并找到关于qi::omit 的链接，我意识到我可以关联一个语义动作然后省略结果。

我必须处理的格式是多余的（大小与元素的数量是多余的），所以我必须在语义上在任何情况下省略一些东西。

    using namespace sqi;
    std::string const v_str = "3 AA BB CC";
    {
        std::vector<std::string> v;
        auto it = begin(v_str);
        bool r = sqi::phrase_parse(
            it, end(v_str), 
            omit[int_] >> *lexeme[+(char_-' ')],
            space, v
        );
        assert( v.size() == 3 and v[2] == "CC" );
    }

但这并不意味着我不能将省略的（冗余）部分用于优化目的或一致性检查。

    {
        std::vector<std::string> v;
        auto it = begin(v_str);
        bool r = sqi::phrase_parse(
            it, end(v_str), 
            omit[int_[([&](int n){v.reserve(n);})]] >> *lexeme[+(char_-' ')],
            space, v
        );
        assert( v.size() == 3 and v[2] == "CC" );
    }

我同意语义行为是邪恶的，但我认为只有当它们改变接收器对象的状态时。 可以说reserve 不会改变向量的状态。

事实上，这样我可以通过reserve 优化内存使用，也可以通过使用repeat 而不是无限的kleene* 来优化解析器的执行。 (Apparently repeat can be more efficient).

    {
        std::vector<std::string> v;
        auto it = begin(v_str);
        int n;
        bool r = sqi::phrase_parse(
            it, end(v_str), 
            omit[int_[([&](int nn){v.reserve(n = nn);})]] >> repeat(phx::ref(n))[lexeme[+(char_-' ')]],
            space, v
        );
        assert( n == v.size() and v.size() == 3 and v[2] == "CC" );
    }

（取消phx::ref 是基础，因为必须延迟对n 的评估）