使用try-catch块从文件读取行以获取异常C ++

Question

I want to read lines in certain length and parse them. To parse them I use exceptions to take care of specific bad inputs, but whenver I catch an error my buffer is filled with bad input and the next getline command puts gibberish in it even though there is still valid input in the file.

Here is my code:

( inStream is of type istream because if the file is invalid I read from 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();
    }
}

After the first time I catch exception from parse (already in the catch block) buffer is filled with junk and not the original contents, also the next iteration of the loop fills buffer with junk and not the input. I tried using clear() and ignore(MAX_LINE_LENGTH, '\\n') after the catch blocks but it didn't help. What can I do? I want to read MAX_LINE_LENGTH chars at most so that if I get more than that in a single line I read it in the next iteration.

I read from a file (not redirecting), here's how:

ifstream  inpFile;
ofstream outFile;

/* I receive the files' names via argv, some are input some are output
 * (order is fixed but not the number)
 * /.prog outpu1 input1 output2 input2 (and so on)
 * degenerated example on how It works:
 *    for(int i=argc-1; i>0; i-=2){
 *       inpFile.open(argv[i]);
 *       if(inpFile.is_open()) return true;
 *    }
 */
if (!initFiles (argc, argv, inpFile, outFile))
    return 1;

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

Answer 1

You'll have to supply more information. The following works just fine when compiled with g++ 5.1.1 on Fedora. Obviously, I had to create some of the missing infrastructure to get it to compile and run but I don't think I took too many liberties.

#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;
}

Since you're not really explained what you're ultimately trying to do you will probably have to refactor this in terms of processing the pieces of the input. istream.getline() deals in raw characters and can be 'fiddly'