Reading file line by line WITHOUT using FOR/WHILE loop

Question

Hey guys here's a interesting challenge for you all. I'm given a text file and I'm supposed to process the information line by line. The processing part is trivial so long as I can obtain the individual lines. However here's the challenge:

I must do so WITHOUT using any FOR/WHILE loops in my code. (This include recursions)
I am only allowed to use the standard C++ library.

Currently right now my best solution is this: Is there a C++ iterator that can iterate over a file line by line? but I'm hoping for a better one that does not involve creating my own iterator class or implementing a proxy for std::string.

P.S. this is for a school assignment and the challenge here was to solve the problem using a combination of std functionalities and algorithms but I have no clue how to go about solving it

This is pretty senseless, if your parsing something line by line your literally looping over the file — Sebastian Hoffmann, Apr 05 '13 at 16:58
With silly requirements like this, `goto` is the best way to go. — nneonneo, Apr 05 '13 at 16:59
Its actually for a school assignment. The challenge here is to attempt to complete the assignment using a combination of standard library algorithm and functionalities but I have no idea how to go about doing so — Cheng Lai, Apr 05 '13 at 17:01
Yes I do know about for_each and was considering using a combination of that together with implementing my own iterator to iterate through the text file line by line but I trying to find a more elegant solution — Cheng Lai, Apr 05 '13 at 17:07
for and while loops include recursion? I find that a disturbing view. :) — Sarien, Apr 05 '13 at 17:08
the lecturer banned the use of recursion when I suggested it =p — Cheng Lai, Apr 05 '13 at 17:10

sbabbi · Accepted Answer · 2013-04-05T17:15:56.507

6

ifstream input("somefile")

if (!input) { /* Handle error */ }

//MyDataType needs to implement an operator>>

std::vector<MyDataType> res;

std::istream_iterator<MyDataType> first(input);
std::istream_iterator<MyDataType> last;
std::copy(first,last, std::back_inserter(res));

//etc..

Your input operator can be something like this:

std::istream& operator>>(std::istream &in,MyDataType & out)
{
    std::string str;
    std::getline(in,str);
    //Do something with str without using loops
    return in;
}

There are a lot of loops here (you dont' want to use goto, don't you?), but they are all hidden behind std::copy and std::getline

edited Apr 05 '13 at 17:15

answered Apr 05 '13 at 17:05

sbabbi

11,070
2
29
57

1

Don't you mean `operator >>`? – Angew is no longer proud of SO Apr 05 '13 at 17:06
that actually very similar to the answer from the link I posted and I was gonna use it as a last resort if I can't find anything – Cheng Lai Apr 05 '13 at 17:12
@Angew zzz.. sorry i fixed it – sbabbi Apr 05 '13 at 17:15
@sbabbi has the right direction. He could also overload `std::find` however I'm not familiar enough with it to provide an example. – inetknght Apr 05 '13 at 19:10

score 0 · Answer 2 · answered Apr 05 '13 at 18:03

This is just a toy.

It consists of a Generator based way to slurp up files (which I find easy to write), together with a half-working adapter that turns Generators into Iterators.

A Generator in this context is a functor that takes a lambda, and passes that lambda the thing iterated over and returns true, or returns false. It makes a really short loop:

while( gen( [&]( std::string line ) {
  // code using line goes here
} ) ); // <- notice that this is an empty while loop that does stuff

but you aren't allowed to use that. (This design is inspired by python generators, which I honestly find much more natural to work with than C++ iterators for many kinds of problem, which includes reading from a file).

The adpator takes this generator and makes it an iterator, so you can pass it to for_each.

The point of this is that your question itself is inane, so rather than do something obvious (goto, or directly use for_each on an istream iterator), I'm proposing messing around with something obtuse and different. :)

The Line generator is nice and short:

struct LineGenerator {
  LineGenerator(std::ostream& os_):os(&os_) {}
  std::ostream* os;
  template<typename F>
  bool operator()(F&& func) {
    std::string s;
    bool bRet = std::getline( *os, s );
    if (!bRet) return false;
    std::forward<F>(func)(s);
    return true;
  }
};

The adaptor, on the other hand, is pretty messy: (and not tested)

template<typename Generator>
struct generator_iterator {
  typedef generator_iterator<Generator> my_type;
  typedef typename std::decay< decltype( std::declval<Generator>()() ) >::type value_type;
  Generator g;
  bool bDone;
  value_type val;
  generator_iterator( Generator g_ ):g(g_), bDone(false) {
    next();
  }
  generator_iterator(): bDone(true) {}
private:
  void next() {
    if (bDone) return;
    bDone = g(val);
  }
public:
  generator_iterator& operator++() {
    next();
    return *this;
  }
  value_type operator*() {
    return val;
  }
  const value_type operator*() const {
    return val;
  }
  value_type* operator->() {
    return &val;
  }
  value_type const* operator->() const {
    return &val;
  }
  bool operator==( my_type const& o ) {
    if (bDone != o.bDone) return false;
    if (!bDone && !o.bDone) return true;
    return false;
  }
};
template<typename Generator>
generator_iterator<Generator> make_gen_it( Generator&& g ) {
  return generator_iterator<Generator>( std::forward<Generator>(g) );
}
template<typename Generator>
generator_iterator<Generator> make_end_gen_it() {
  return generator_iterator<Generator>();
}

I hope this amuses!

Reading file line by line WITHOUT using FOR/WHILE loop

2 Answers2

Linked