c++ - 关于使用iostream进行解析的准则是什么？

Question

我发现自己最近写了很多解析代码(大多数是自定义格式，但这并不重要)。

为了提高可重用性，我选择将解析函数基于I / O流，以便可以将它们与boost::lexical_cast<>一起使用。

但是，我意识到我从未读过任何有关如何正确执行此操作的信息。

为了说明我的问题，让我们考虑一下我有三个类Foo，Bar和FooBar:
Foo由数据以以下格式表示:string(<number>, <number>)。
Bar由数据以以下格式表示:string[<number>]。
FooBar是一种变体类型，可以容纳Foo或Bar。

现在假设我为operator>>()类型写了一个Foo:

istream& operator>>(istream& is, Foo& foo)
{
    char c1, c2, c3;
    is >> foo.m_string >> c1 >> foo.m_x >> c2 >> std::ws >> foo.m_y >> c3;

    if ((c1 != '(') || (c2 != ',') || (c3 != ')'))
    {
      is.setstate(std::ios_base::failbit);
    }

    return is;
}

对于有效数据，解析正常。但是，如果数据无效:

foo可能被部分修改；

输入流中的某些数据已读取，因此不再可用于进一步调用is。

另外，我为自己的 operator>>()类型写了另一个 FooBar:

istream& operator>>(istream& is, FooBar foobar)
{
  Foo foo;

  if (is >> foo)
  {
    foobar = foo;
  }
  else
  {
    is.clear();

    Bar bar;

    if (is >> bar)
    {
      foobar = bar;
    }
  }

  return is; 
}

但是很显然这是行不通的，因为如果 is >> foo失败，则表明某些数据已经被读取，并且不再可用于 is >> bar的调用。

所以这是我的问题:

我的错误在哪里？

是否应该有人对operator>>进行调用，以使失败后的初始数据仍然可用？如果是这样，我如何有效地做到这一点？

如果没有，是否有办法“存储”(和还原)输入流的完整状态:状态和数据？

failbit和badbit之间有什么区别？我们什么时候应该使用其中一个？

是否有任何在线引用(或书籍)深入解释了如何处理iostream？不只是基本的东西:完整的错误处理。

非常感谢你。

Answer 1

就我个人而言，我认为这是合理的问题，并且我非常记得自己自己在为之奋斗。所以我们开始:

Where is my mistake here ?

我不会说这是一个错误，但是您可能想要确保您不必退出阅读的内容。也就是说，我将实现输入功能的三个版本。根据特定类型解码的复杂程度，我什至可能不会共享代码，因为无论如何它可能只是一小段。如果超过一行或两行，则可能会共享代码。也就是说，在您的示例中，我将拥有一个 FooBar的提取器，该提取器实际上会读取 Foo或 Bar成员并相应地初始化对象。或者，我将阅读开头部分，然后调用提取公用数据的共享实现。

让我们做这个练习，因为有些事情可能会很复杂。从您对格式的描述中，我不清楚“字符串”和字符串后面的内容是否定界，例如由空格(空格，制表符等)组成。如果没有，您不能只读取 std::string:它们的默认行为是读取直到下一个空格。有多种方法可以将流调整为将字符视为空格(使用 std::ctype<char>)，但我仅假设存在空间。在这种情况下， Foo的提取器可能看起来像这样(注意，所有代码都是 ，完全是，未经测试):

std::istream& read_data(std::istream& is, Foo& foo, std::string& s) {
    Foo tmp(s);
    if (is >> get_char<'('> >> tmp.m_x >> get_char<','> >> tmp.m_y >> get_char<')'>)
        std::swap(tmp, foo);
    return is;
}
std::istream& operator>>(std::istream& is, Foo& foo)
{
    std::string s;
    return read_data(is >> s, foo, s);
}

这个想法是 read_data()读取了 Foo的一部分，该部分不同于 Bar，当读取 FooBar时。类似的方法将用于 Bar，但我忽略了这一点。更有趣的是使用了这个有趣的 get_char()函数模板。这就是所谓的操纵器，它只是一个将流引用作为参数并返回流引用的函数。由于我们要读取和比较不同的字符，因此我将其作为模板，但每个字符也可以具有一个功能。我懒得打出来:

template <char Expect>
std::istream& get_char(std::istream& in) {
    char c;
    if (in >> c && c != 'e') {
        in.set_state(std::ios_base::failbit);
    }
    return in;
}

我的代码看起来有点怪异的是，几乎没有检查是否可行。那是因为当读取成员失败时，流只会设置 std::ios_base::failbit，而我真的不必打扰自己。实际添加特殊逻辑的唯一情况是在 get_char()中处理期望的特定字符。同样，也不会跳过任何空白字符(即使用 std::ws):所有输入函数都是 formatted input函数，默认情况下会跳过空白(您可以使用 in >> std::noskipws将其关闭)，但随后很多事情将无法正常工作。

通过读取 Bar的类似实现，读取 FooBar看起来像这样:

std::istream& operator>> (std::istream& in, FooBar& foobar) {
    std::string s;
    if (in >> s) {
         switch ((in >> std::ws).peek()) {
         case '(': { Foo foo; read_data(in, foo, s); foobar = foo; break; }
         case '[': { Bar bar; read_data(in, bar, s); foobar = bar; break; }
         default: in.set_state(std::ios_base::failbit);
         }
    }
    return in;
 }

该代码使用未格式化的输入函数 peek()，它仅查看下一个字符。它要么返回下一个字符，要么如果失败则返回 std::char_traits<char>::eof()。因此，如果有左括号或左括号，我们将使用 read_data()接管。否则，我们总是失败。解决了眼前的问题。继续分发信息...

Should one write his calls to operator>> to leave the initial data still available after a failure ?

普遍的答案是:不。如果您未能阅读，则出了点问题，您就放弃了。不过，这可能意味着您需要加倍努力才能避免失败。如果您确实需要退出分析数据的位置，则可能需要先使用 std::string将数据读取到 std::getline()中，然后再分析此字符串。使用 std::getline()假定要停止一个不同的字符。默认为换行符(因此命名)，但是您也可以使用其他字符:

std::getline(in, str, '!');

这将在下一个感叹号处停止并将所有字符存储在 str中。它还会提取终止符，但不会存储它。有时，当您读取文件的最后一行(可能没有换行符)时，这很有意思: std::getline()如果可以读取至少一个字符，则表示成功。如果您需要知道文件中的最后一个字符是否为换行符，则可以测试流是否已到达:

如果(std::getline(in，str)&& in.eof()){std::cout <<“文件未以换行符结尾\“; }

If so, how can I do that efficiently ?

从本质上讲，流是单次通过:每个字符只接收一次，如果跳过一个字符，则将其消耗掉。因此，您通常希望以不必回溯的方式来构造数据。就是说，这并非总是可能的，大多数流实际上在后台有一个缓冲区，可以返回字符。由于流可以由用户实现，因此不能保证可以返回字符。即使对于标准流，也没有真正的保证。

如果要返回一个字符，则必须完全放回提取的字符:

char c;
if (in >> c && c != 'a')
    in.putback(c);
if (in >> c && c != 'b')
    in.unget();

后一个功能的性能稍好一些，因为它不必检查字符是否确实是提取的那个字符。它还有更少的失败机会。从理论上讲，您可以放回任意数量的字符，但是大多数情况下，大多数流都不会支持多个字符:如果有缓冲区，则标准库将负责“取消加粗”所有字符，直到缓冲区开始到达了。如果返回另一个字符，它将调用虚拟函数 std::streambuf::pbackfail()，该函数可能会或可能不会提供更多的缓冲区空间。在我实现的流缓冲区中，它通常只会失败，即，我通常不会覆盖此功能。

If not, is there a way to "store" (and restore) the complete status of an input stream: state and data ?

如果您打算完全恢复您所处的状态(包括字符)，那么答案是:确定存在。 ...但是没有 简易方式。例如，您可以实现一个过滤流缓冲区并如上所述放回字符以恢复要读取的序列(或支持在流中查找或显式设置标记)。对于某些流，您可以使用搜索，但并非所有流都支持此功能。例如， std::cin通常不支持搜索。

不过，恢复角色只是故事的一半。您要还原的其他内容是状态标志和任何格式数据。实际上，如果流进入失败状态甚至是坏状态，则需要在流将执行大多数操作之前清除状态标志(尽管我认为格式化东西仍然可以重置):

std::istream fmt(0); // doesn't have a default constructor: create an invalid stream
fmt.copyfmt(in);     // safe the current format settings
// use in
in.copyfmt(fmt);     // restore the original format settings

函数 copyfmt()复制与流相关的所有与格式相关的字段。这些是:

语言环境

fmtflags

信息存储iword()和pword()

流的事件

异常(exception)

流的状态

如果您不了解其中的大多数内容，请不要担心:您可能不会在意的大多数内容。好吧，直到您需要它为止，但到那时为止，您已经希望获得一些文档并阅读有关它(或询问并获得良好的答复)。

What differences are they between failbit and badbit ? When should we use one or the other ?

最后是一个简短的说明:

当检测到格式化错误时设置

failbit，例如应该有一个数字，但是找到了字符“T”。

当流的基础结构出现问题时，设置

badbit。例如，当未设置流缓冲区时(如上面的流fmt中一样)，该流已设置了std::badbit。另一个原因是是否引发了异常(并通过exceptions()掩码捕获；默认情况下捕获了所有异常)。

Is there any online reference (or a book) that explains deeply how to deal with iostreams ? not just the basic stuff: the complete error handling.

啊，是的，很高兴你问。您可能想要获得Nicolai Josuttis的“C++标准库”。我知道这本书描述了所有细节，因为我为编写本书做出了贡献。如果您真的想知道 有关IOStreams和语言环境的所有信息，则需要Angelika Langer和Klaus Kreft的“IOStreams和语言环境”。如果您想知道我从哪里得到的信息:这是史蒂夫·蒂尔(Steve Teale)的“IOStreams”，我不知道这本书是否仍在打印中，并且缺少很多标准化过程中引入的内容。由于我实现了自己的IOStreams(和语言环境)版本，所以我也了解这些扩展。