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 to 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

In C++20, an initialization statement (which must end with a semicolon) can be present before the range declaration. Therefore, the general form becomes the following:

for(init-statement 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. Conversely, the end expression is only evaluated once, and not every time the loop is iterated, which could potentially increase performance.

As mentioned in the previous section, in C++20, an initialization statement can be present before the range declaration. This has the effect that the compiler-generated code for a range-based for loop has the following form:

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

The initialization statement can be an empty statement, an expression statement, a simple declaration, or, starting with C++23, an alias declaration. An example is shown in the following snippet:

for (auto rates = getRates(); int rate : rates)
{
   std::cout << rate << '\n';
}

Prior to C++23, this was helpful to avoid undefined behavior with temporaries in range expressions. The lifetime of a temporary returned by the range-expression is extended until the end of the loop. However, the lifetime of temporaries within the range-expression is not extended if they will be destroyed at the end of range-expression.

We will explain this with the help of the following snippet:

struct item
{
   std::vector<int> getRates()
   {
      return std::vector<int> {1, 1, 2, 3, 5, 8, 13};
   }
};
item make_item()
{
   return item{};
}
// undefined behavior, until C++23
for (int rate : make_item().getRates())
{
   std::cout << rate << '\n';
} 

Since make_item() returns by value, we have a temporary within range-expression. This introduces undefined behavior, which can be avoided with an initialization statement, as follows:

for (auto item = make_item(); int rate : item.getRates())
{
   std::cout << rate << '\n';
}

This problem no longer manifests in C++23, because this version of the standard also extends the lifetime of all the temporaries within the range-expression until the end of the loop.

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
• Chapter 12, Iterating over collections with the ranges library, to learn about the fundamentals of the C++20 ranges library
• Chapter 12, Creating your own range view, to see how to extend the C++20 range library’s capabilities with user-defined range adaptors