What does “ for (const auto &s : strs) {} ” mean?

Question

What does for (const auto &s : strs) mean? What is the function of colon :?

vector<string> &strs;
for (const auto &s : strs){
   //
}

Answer 1

According to 6.5.4 The range-based for statement [stmt.ranged] the statement

for ( for-range-declaration : expression ) statement

is equivalent to

{
    auto && __range = range-init;
    for (auto __begin = begin-expr, __end = end-expr; __begin != __end; ++__begin ) {
       for-range-declaration = *__begin;
       statement
    }
}

In other words, the compiler will expand it to a regular for-loop going from the begin() and end() of the expression.

There are some conditions about name lookup of begin-expr and end-expr, but all Standard Library containers (such as your std::vector), std::initializer_list, raw arrays and anything with member or non-member begin() and end() functions in the right namespace will be accepted.

The : is simply the syntax to separate the declaration of what you use inside the loop from the expression which you loop over.

Answer 2

It's actually a C++11 feature called "range-based for-loops".

In this case, it's basically an easier-to-write replacement for:

// Let's assume this vector is not empty.
vector<string> strs;

const vector<string>::iterator end_it = strs.end();

for (vector<string>::iterator it = strs.begin(); it != end_it; ++it) {
  const string& s = *it;
  // Some code here...
}

The : is part of the new syntax.

On the left you basically have a variable declaration that will be bound to the elements of the vector and one the right you have the variable to iterate on (also called "range expression").

Here is an excerpt of the linked documentation that explains the prerequisites for the range-expressions:

range_expression is evaluated to determine the sequence or range to iterate. Each element of the sequence, in turn, is dereferenced and assigned to the variable with the type and name given in range_declaration.

begin_expr and end_expr are defined as follows:

If __range is an array, then begin_expr is __range and end_expr is (__range + __bound), where __bound is the number of elements in the array (if the array has unknown size or is of an incomplete type, the program is ill-formed)

If __range's type is a class type with either or both a begin or an end member function, then begin_expr is __range.begin() and end_expr is __range.end();

Otherwise, begin_expr is begin(__range) and end_expr is end(__range), which are found via argument-dependent lookup with std as an associated namespace.

Note that thanks to all this, range-based for loops also support iterating over C arrays as std::begin/std::end works with those too.