Using range-based for loops to iterate on a range

Many programming languages support a variant of a for loop called for each; that is, repeating a group of statements over the elements of a collection. C++ did not have core language support for this until C++11. The closest feature was the general-purpose algorithm from the standard library called std::for_each, which applies a function to all the elements in a range. C++11 brought language support for for each that's actually called range-based for loops. The new C++17 standard provides several improvements for the original language feature.

Getting ready

In C++11, a range-based for loop has the following general syntax:

for ( range_declaration : range_expression ) loop_statement

To exemplify the various ways of using range-based for loops, we will use the following functions, which return sequences of elements:

std::vector<int> getRates()
{
  return std::vector<int> {1, 1, 2, 3, 5, 8, 13};
}
std::multimap<int, bool> getRates2()
{
  return std::multimap<int, bool> {
    { 1, true },
    { 1, true },
    { 2, false },
    { 3, true },
    { 5, true },
    { 8, false },
    { 13, true }
  };
}

In the next section, we'll look at the various ways we can use range-based for loops.

How to do it...

Range-based for loops can be used in various ways:

• By committing to a specific type for the elements of the sequence:

  auto rates = getRates();
  for (int rate : rates)
    std::cout << rate << '\n';
  for (int& rate : rates)
    rate *= 2;
  

• By not specifying a type and letting the compiler deduce it:

  for (auto&& rate : getRates())
    std::cout << rate << '\n';
  for (auto & rate : rates)
    rate *= 2;
  for (auto const & rate : rates)
    std::cout << rate << '\n';
  

• By using structured bindings and decomposition declaration in C++17:

  for (auto&& [rate, flag] : getRates2())
    std::cout << rate << '\n';
  

How it works...

The expression for the range-based for loops shown earlier in the How to do it... section is basically syntactic sugar as the compiler transforms it into something else. Before C++17, the code generated by the compiler used to be the following:

{
  auto && __range = range_expression;
  for (auto __begin = begin_expr, __end = end_expr;
  __begin != __end; ++__begin) {
    range_declaration = *__begin;
    loop_statement
  }
}

What begin_expr and end_expr are in this code depends on the type of the range:

• For C-like arrays: __range and __range + __bound (where __bound is the number of elements in the array).
• For a class type with begin and end members (regardless of their type and accessibility): __range.begin() and __range.end().
• For others, it is begin(__range) and end(__range), which are determined via argument-dependent lookup.

It is important to note that if a class contains any members (function, data member, or enumerators) called begin or end, regardless of their type and accessibility, they will be picked for begin_expr and end_expr. Therefore, such a class type cannot be used in range-based for loops.

In C++17, the code generated by the compiler is slightly different:

{
  auto && __range = range_expression;
  auto __begin = begin_expr;
  auto __end = end_expr;
  for (; __begin != __end; ++__begin) {
    range_declaration = *__begin;
    loop_statement
  }
}

The new standard has removed the constraint that the begin expression and the end expression must be the same type. The end expression does not need to be an actual iterator, but it has to be able to be compared for inequality with an iterator. A benefit of this is that the range can be delimited by a predicate. On the other hand, the end expression is only evaluated once, and not every time the loop is iterated, which could potentially increase performance.

See also

• Enabling range-based for loops for custom types to see how to make it possible for user-defined types to be used with range-based for loops
• Iterating over collections with the ranges library in Chapter 12, C++20 Core Features, to learn about the fundamentals of the C++20 ranges library
• Creating your own range view in Chapter 12, C++20 Core Features, to see how to extend the C++20 range library's capabilities with user-defined range adaptors