Question

我想读取一定长度的行并解析它们。为了解析它们，我使用异常来处理特定的错误输入，但是当我发现错误时，我的缓冲区充满了错误的输入，并且下一个getline命令会在其中放入乱码，即使文件中仍然存在有效输入。

这是我的代码：

（inStream属于istream类型，因为如果文件无效，我会从cin读取

char buffer[MAX_LINE_LENGTH];
string line;
while (inStream.getline(buffer,MAX_LINE_LENGTH)) {
    line=string(buffer);

    try {
        parse(line, inStream, outStream);
    }

    catch(const DoneError& e){
        outStream<<e.what();
        return 0;
    }

    catch(const MyException& e) {
        outStream<<e.what();
    }

    //invalid_argument or out_of_range at stod & stoi
    catch (const logic_error& e)    {
        outStream<<BadParameterExeption().what();
    }

    catch(const exception& e){
        outStream<<e.what();
    }
}

第一次从parse捕获异常（已经在catch块中）buffer填充了垃圾而不是原始内容，循环的下一次迭代填充{{1}与垃圾而不是输入。我尝试在catch块之后使用buffer和clear()，但它没有帮助。我能做什么？我想最多读取MAX_LINE_LENGTH个字符，这样如果我在一行中得到的字数超过了一行，我会在下一次迭代中读取它。

我从一个文件中读取（不是重定向），这里是如何：

ignore(MAX_LINE_LENGTH, '\n')

Answer 1

您必须提供更多信息。在Fedora上使用g ++ 5.1.1编译时，以下工作正常。显然，我不得不创建一些缺少的基础设施来编译和运行它，但我不认为我有太多的自由。

#include <iostream>
#include <fstream>
#include <exception>
#include <stdexcept>
#include <string>

using namespace std;

#define min(x, y) (x < y) ? x : y

const int MAX_LINE_LENGTH = 80;

struct DoneError : public exception
{
   const char *what() const throw()
   {
      return "Done Exception";
   }
};

struct MyException : public exception
{
   const char *what() const throw()
   {
      return "MyException";
   }
};

struct BadParameterExeption : public exception
{
   const char *what() const throw()
   {
      return "Bad Parameter";
   }
};

void parse(string l, istream &is, ostream &os)
{
   if (l.find("MyException") != string::npos)
      throw MyException();

   if (l.find("Done") != string::npos)
      throw DoneError();

   if (l.find("logic") != string::npos)
      throw logic_error("You made a logic error");

   if (l.find("BadParameter") != string::npos)
      throw BadParameterExeption();
}


int main(int argc, char **argv)
{
   ifstream inpFile(argv[1]);
   ofstream outFile(argv[2]);

   istream &inStream = (inpFile.is_open()) ? inpFile : cin;
   ostream &outStream = (outFile.is_open()) ? outFile : cout;

   char buffer[MAX_LINE_LENGTH];
   string line;
   try {
      while (getline(inStream, line, '\n'))
      {
          while (line.length() > 0)
          {
             string smaller = line.substr(0, min(MAX_LINE_LENGTH, line.length()));
             line = line.substr(min(MAX_LINE_LENGTH, line.length()));
             try {
                 parse(smaller, inStream, outStream);
             }

          catch(const DoneError& e){
              outStream<<e.what()<<endl;;
              return 0;
          }

          catch(const MyException& e) {
              outStream<<e.what()<<endl;;
          }

    //invalid_argument or out_of_range at stod & stoi
          catch (const logic_error& e)    
          {
              outStream<<BadParameterExeption().what()<<endl;;
          }

          catch(const exception& e){
             outStream<<e.what()<<endl;;
          }
         }
      }
   }
   return 0;
}

由于您并未真正解释您最终会尝试做什么，因此您可能需要在处理输入内容时对其进行重构。 istream.getline（）处理原始字符，并且可以“fiddly＆＃39;

使用try-catch块读取文件中的行以用于异常C ++

1 个答案: