that the C++17 standard brought to C++ as a language, so we can concentrate on the
additions to the STL in the following chapters.
Chapter 2, STL Containers, explains how the STL's rich variety of container data structures
got some upgrades with C++17. After having a look at the entire collection of the different
containers, we will have a closer look on the new additions they got.
Chapter 3, Iterators, explains iterators, which are an extremely important abstraction as they
are the glue between the STL's algorithms and the container data structures, whenever they
are combined. We are going to roll up the whole iterator concept from the ground to learn
how to put them to the best use in all our programs.
Chapter 4, Lambda Expressions, explores lambda expressions, which allow for some very
interesting programming patterns. Inspired by purely functional programming languages,
lambda expressions, which were first introduced in C++11, got some new features with
C++14 and C++17.
Chapter 5, STL Algorithm Basics, introduces the basics of the STL’s standard algorithms that
are easy to use, very performant, well-tested, and highly generic. We will learn how to use
them, so we can be productive by concentrating on solutions, instead of wasting time
reinventing the wheel.
Chapter 6, Advanced Use of STL Algorithms, demonstrates how to combine the STL’s basic
algorithms in order to compose more complex ones in clean ways without code duplication.
In this chapter, we will be creative and stick tightly to the STL while implementing
solutions to more complex problems, and we will learn how to combine existing algorithms
to create new ones that really fit our needs.
Chapter 7, Strings, Stream Classes, and Regular Expressions, provides a detailed overview
over the STL's powerful classes around strings, generic I/O streaming, and regular
expressions. We will have an in-depth look into these parts of the STL in this chapter.
Chapter 8, Utility Classes, explains the STL ways of generating random numbers, taking
and measuring the time, managing dynamic memory, elegantly signalizing error
conditions, and more. We will have a look at the extremely useful and portable utility
classes that the C++ STL provides for such tasks and introduce the brand new ones that
came with C++17.
Chapter 9, Parallelism and Concurrency, showcases the existing C++ extensions for
parallelism and concurrency which became very important topics at the time we entered the
era of multi-core processors. First C++11, and then C++17, came with great additions that are
of an enormous help whenever we need to implement programs that run on multiple cores
and do things concurrently. So, we make sure we grasp these concepts in this chapter.
Chapter 10, Filesystem, shows that although the STL always provided support for reading
and manipulating individual files, C++17 got a lot of new value with its whole new
operating system-independent library for the handling of filesystem paths and the traversal
of directories. In this chapter, we will learn how to use it.