Hi All, I've extended the ifstream class with a routine to skip headers, but it appears to me to be somewhat awkward...interested in best practice...here's the code: (template specialization...could use inheritance instead.) void IO<ifstream>::skipLines(intu n) { string _null_; for ( intu i = 0; i < n; ++i ) { std::getline(*this,_null_); } } This has become so routine in file i/o, that I've built it into the class constructor: IO<ifstream>::IO(const string & filename, intu n) { openFile(filename); // openFile checks for open errors. skipLines(n); } Any suggestions for better efficiency? Any better STL approach? --random

You could write t up as as stream manipulator, similar to std::ws, std::setw, etc... that way, it would work for any stream, not just your specialized stream.

Given that you mention "skipping headers", are you really trying to skip a given number of lines, or lines beginning with a specific character/set of characters (like # or //) ?

Hi Fruny,

I've written a state machine that will ignore comments ( C++ style, //) and reassemble the rough data file in neat line-by-line form which is written to a 'state' file, which I then read in line-by-line as data only (except for the state file header which contains a copyright statement and date-stamp). This gives me fine-grained control on the newlines, spaces, delimiters and comments. It also means that I can put the rough data in tablular or line-by-line format and read in strings without using quotes.

Eventually I'll eliminate the 'state' file in favour of a temporary stream buffer but for the moment I'm using it for debugging purposes.

I've done it this way so that at a later date I can integrate a web browser to interface and compose the data files.

What would you suggest as a stream manipulator?

--random

So, for example, when the data is read to the Project struct instance, it is read line by line something like this:

using namespace std;

Project datastruct;
string statefile = "file.st";
intu header_size_ = 3;

Input in(statefile,header_size_); // where Input is a typedef to IO<ifstream>

in.getData(datastruct.record_no); // This is an unsigned int.
in.getData(datastruct.name); // This is a string.
in.getData(datastruct.value); // This is a float.
.
.
.
etc.

where the overloaded getData() method is an part of the IO specialization that reads a line of data into the variable (regardless of type) and goes to the next line.

--random

Well, to skip a line, the cleanest way is to do

stream.ignore(std::numeric_limits<int>::max(), '\n');

A character count equal to std::numeric_limits<int>::max() is handled as a special case meaning "any number of characters".

A parameterless stream manipulator is simply a function that takes and returns a stream reference. operator>> (operator<< for ostreams) is overloaded to call the function when passed such a function pointer: std::endl is a function, std::cout << std::endl calls std::endl(std::cout).

So in our case:



Now stream >> skipline will skip a line.

Things get slightly more complicated if you want to be able to specify the number of lines to skip as C++ does not support currying (passing some of the parameters to a function, leaving the others unbound, getting a function in return) - though boost::bind gets us halfway. So we need to create a class which, when passed to operator>>, will just to the righ



Now stream >> skipline(n) will skip n lines.

As much as you might want to (I did for a while, was about to write it up and then remembered), these two approaches do not mix. If you were to write an overloaded skipline function, either directly performing the operation or, if passed an integer, returning an object which, when streamed, would perform the operation, you would have to disambiguate with a cast which function call you intend when just passing the function pointer, which would be inconvenient considering we're trying to make the syntax as smooth as possible.

I am sure you can build on that model to write manipulators that skip comments, or something similar.

Thanks Fruny,

Actually, you've given me a lot of ideas regarding parameterless stream manipulators that could be used elsewhere in my code.

I know that a lot of books on C++ recommend getting each line (with getline(...)) and sending it to a 'null' string. But this just didn't seem right to me, although it works. Plus getline(...) is a little tricky in that even with the declaration 'using namespace std;' the compiler must have the std::getline(..) form.

Your suggestion to use stream.ignore(...) is a much more logical approach, I think, and I'll take on board the excellent concepts that you've given.

All the best!

--random