Book Image

Modern C++ Programming Cookbook - Second Edition

By : Marius Bancila
Book Image

Modern C++ Programming Cookbook - Second Edition

By: Marius Bancila

Overview of this book

C++ has come a long way to be one of the most widely used general-purpose languages that is fast, efficient, and high-performance at its core. The updated second edition of Modern C++ Programming Cookbook addresses the latest features of C++20, such as modules, concepts, coroutines, and the many additions to the standard library, including ranges and text formatting. The book is organized in the form of practical recipes covering a wide range of problems faced by modern developers. The book also delves into the details of all the core concepts in modern C++ programming, such as functions and classes, iterators and algorithms, streams and the file system, threading and concurrency, smart pointers and move semantics, and many others. It goes into the performance aspects of programming in depth, teaching developers how to write fast and lean code with the help of best practices. Furthermore, the book explores useful patterns and delves into the implementation of many idioms, including pimpl, named parameter, and attorney-client, teaching techniques such as avoiding repetition with the factory pattern. There is also a chapter dedicated to unit testing, where you are introduced to three of the most widely used libraries for C++: Boost.Test, Google Test, and Catch2. By the end of the book, you will be able to effectively leverage the features and techniques of C++11/14/17/20 programming to enhance the performance, scalability, and efficiency of your applications.
Table of Contents (16 chapters)
13
Bibliography
14
Other Books You May Enjoy
15
Index

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