I think people sometimes feel compelled to combine auto and the range based for loop when they shouldn't. In this example the range based for loop adds clarity but the use of auto doesn't. I would have written something like:

    for(const string &s : data) {
        ofile << s << std::endl;
    }

which is a lot more clear about what type of thing you're getting out of the vector on each iteration.

Actually, the only thing this tells you about what you are getting out of the vector is that it can be implicitly converted to a string.

If data is a vector of, for example, pointers to const char, on each iteration this code will unnecessarily copy each item into a temporary string before printing it. Using auto would avoid this step, regardless of data's type.

Note that the typical non-range-based for loop also omits the vector item type... Is this that much less clear?:

  for (int i = 0; i < data.size(); ++i) {
      ofile << data[i] << std::endl;
  }

That's a good point, but when I think of the typical code for non-range-based for loop it looks like:

    for (vector<string>::iterator i = data.begin(); i != data.end(); ++i) {
        ofile << *i << std::endl;
    
    }

which makes it pretty clear what types we're dealing with.

I think in C++1y we'll be able to define a function 'foreach' that we can use like:

    foreach(data, []<class T>(const T & item) {
        ofile << item << std::endl;
    });

This should eliminate the potential implicit conversion to temp. But I'm not sure it's seriously better than the original range based for with auto.

Traditional C++ would look something like this:

    for (vector<string>::const_iterator it = data.begin(); it != data.end(); ++it) {
      ofile << *it << endl;
    }

But in this case we're dealing with a vector, so you don't need iterators:

    for (unsigned i = 0; i < data.size(); ++i) {
      ofile << data[i] << endl;
    }

Ugh, define need. If sanity is required, stick to iterators.

Iterators can get very ugly. I like this when there is a need to access elem a lot inside the loop:

  for (size_t i = 0, iEnd = elems.size(); i < iEnd; ++i)
  {
      Elem &elem = elems[i];
      // deal with elem
  }

Of course the new C++11 syntax is king.

I think that some amount of knowledge was assumed. You would have understood it if you had known Java. For-each loops in Java have a very similar syntax.

You probably know something that is similar to Ruby, and that's why you understand it without ever learning it. I bet that you wouldn't understand it if you didn't know any programming language at all.