5

对于我自己的小解析器框架，我正在尝试定义（类似于）以下函数：

template <class T>
// with operator>>( std::istream&, T& )
void tryParse( std::istream& is, T& tgt )
{
    is >> tgt /* , *BUT* store every character that is consumed by this operation
    in some string. If afterwards, is.fail() (which should indicate a parsing
    error for now), put all the characters read back into the 'is' stream so that
    we can try a different parser. */
}

然后我可以写这样的东西：（也许不是最好的例子）

/* grammar: MyData     = <IntTriple> | <DoublePair>
            DoublePair = <double> <double>
            IntTriple  = <int> <int> <int> */
class MyData
{ public:
    union { DoublePair dp; IntTriple it; } data;
    bool isDoublePair;
};

istream& operator>>( istream& is, MyData& md )
{
    /* If I used just "is >> md.data.it" here instead, the
       operator>>( ..., IntTriple ) might consume two ints, then hit an
       unexpected character, and fail, making it impossible to read these two
       numbers as doubles in the "else" branch below. */
    tryParse( is, md.data.it );
    if ( !is.fail() )
        md.isDoublePair = false;
    else
    {
        md.isDoublePair = true;
        is.clear();
        is >> md.data.dp;
    }
    return is;
}

任何帮助是极大的赞赏。

4

4 回答 4

3

这不是流的用途。您应该将要解析的数据读入缓冲区，然后将该缓冲区（最好作为迭代器范围）交给解析它的函数。这可能看起来像这样：

template <class T, class U>
bool tryParse( U & begin, U & end, T & target ) {
    // return true if parse was successful, false otherwise
}

要从 an 读istream入缓冲区，您可以使用 an istream_iterator：

 std::vector< char > buffer(std::istream_iterator<char>(is), std::istream_iterator<char>());

这会在创建向量时将整个流读入向量。

于 2010-09-23T12:29:00.217 回答
3

不幸的是，流只有非常少和基本的回退支持。

上次我需要这个时，我编写了自己的阅读器类，它包装了一个流，但有一个缓冲区可以将内容放回，并且只有在该缓冲区为空时才从流中读取。这些有办法从中获取状态，您可以提交状态或回滚到更早的状态。
状态类的析构函数中的默认操作是回滚，这样您就可以提前解析而无需过多考虑错误处理，因为异常只会将解析器的状态回滚到尝试不同语法规则的点。（我认为这称为回溯。）这是一个草图：

class parse_buffer {
    friend class parse_state;
public:
    typedef std::string::size_type index_type;

    parse_buffer(std::istream& str);

    index_type get_current_index() const;
    void set_current_index(index_type) const;

    std::string get_next_string(bool skip_ws = true) const;
    char get_next_char(bool skip_ws = true);
    char peek_next_char(bool skip_ws = true); 

    std::string get_error_string() const; // returns string starting at error idx
    index_type get_error_index() const;
    void set_error_index(index_type);

    bool eof() const;

    // ...
};

class parse_state {
public:
    parse_state(parse_buffer&);
    ~parse_state();

    void commit();
    void rollback();

    // ...
};

这应该给你一个想法。它没有任何实现，但这很简单，应该很容易重做。此外，真正的代码有许多方便的功能，例如读取分隔字符串的读取函数，如果它是几个给定关键字之一，则使用字符串，读取字符串并将其转换为每个模板参数给定的类型，等等。

这个想法是一个函数将错误索引设置为其起始位置，保存解析状态，并尝试解析直到它成功或陷入死胡同。在后一种情况下，它只会抛出异常。这将破坏parse_state堆栈上的对象，将状态回滚到可以捕获异常并尝试其他方法或输出错误的函数（这是get_error_string()进来的地方。）

如果你想要一个非常快的解析器，这个策略可能是错误的，但是流通常也会变慢。OTOH，我上次使用这样的东西时，我制作了一个在专有 DOM 上运行的 XPath 解析器，用于在 3D 渲染器中表示场景。并不是XPath 解析器从那些试图获得更高帧速率的人那里得到了所有的热情。:)

于 2010-09-23T12:38:43.453 回答
2

把角色放回去很棘手。一些流支持unget()and putback(somechar)，但不能保证你能得到多少个字符（如果有的话）。

一种更可靠的方法是将字符读入缓冲区并对其进行解析，或者存储在第一次解析尝试中读取的字符并在第二次解析时使用该缓冲区。

于 2010-09-23T12:29:41.823 回答
1

streambuf您可以与流成员一起做一些有趣的事情。特别是，您可以直接访问缓冲区的指针。

但是，您无法保证缓冲区的大小。

于 2010-09-23T12:49:42.163 回答