Name: The C++ Standard Library
Author: Rainer Grimm

With the current C++20 standard, C++ has many libraries to offer. My book's key idea is to give you the necessary information to all the standard C++ libraries in a concise way.

The C++ Standard Library

Learn the best programming languages and platforms for website and web app development

Back End

Preface

The C++ standard library consists of many components. This chapter serves two purposes. It should give you a quick overview of the features and a first idea of how to use them.

The Standard Library

Utilities are valuable tools that can be used in many different contexts. They are not bound to a typical domain. That sentence holds for the functions and libraries of this chapter. I explain to you functions that you can apply on arbitrary values or functions which you can use to create new functions and binds them to variables. You can store arbitrary values of arbitrary types in pairs and tuples or build references to arbitrary values. Smart pointers are your tool to implement automatic memory management in C++. To get information about your types, use the type-traits library.

Utilities

The sequence and associative containers of the Standard Template library have a lot in common. For example, the operations to create or delete a container, determine its size, access its elements, assign or swap, are all independent of the type of elements of a container. It is common for the containers to define them with an arbitrary size, and each container has an allocator. Further, you can adjust the size of a container at runtime. The allocator works most of the time in the background. This can be seen for a std::vector . The call std::vector results in a call std::vector> . Because of the std::allocator , you can adjust except for std::array the size of all containers dynamically. However, they have yet more in common. You can access the elements of a container quite easily with an iterator.

Interface of All Containers

The sequence container have a lot in common, but each container has its special domain. Before I dive into the details, I provide an overview of all five sequence containers of the std namespace.

Sequence Containers

C++ has eight different associative containers . Four of them are associative containers with sorted keys: std::set , std::map , std::multiset and std::multimap . The other four are associative containers with unsorted keys: std::unordered_set , std::unordered_map , std::unordered_multiset and std::unordered_multimap . The associative containers are special containers. That means they support all of the operations described in the chapter Interface of all containers.

Associative Containers

C++ has with std::stack , std::queue and std::priority_queue three special sequence containers. I guess most of you know these classic data structures from your education.

Adaptors for Containers

std::span is an object that refers to a contiguous sequence of objects. A C-array, a std::array , a std::vector , and a std::string store their objects in a contiguous memory block. std::span is often called view and is never an owner. The contiguous sequence of objects can be a C-array, a pointer, and a length, or a std::vector . A typical implementation of std::span holds a pointer to its first element and its length. Thanks to std::span you can access subsequences.

Views on Contiguous Sequences

On the one hand, iterators are generalizations of pointers that represents positions in a container. On the other hand, they provide powerful iteration and random access in a container.

Iterators

This chapter is intentionally not exhaustive This book is about the C++ Standard library. Therefore, I will no go into the details of callable units. I provide only as much information as necessary to correctly use them in the Standard Template Library algorithms. An exhaustive discussion of callable units should be part of a book about the C++ core language. 

Callable Units

The Standard Template Library has many algorithms to work with containers and their elements. As the algorithms are function templates, they are independent of the type of container elements. The glue between the containers and algorithms are the iterators. If your container supports the STL container’s interface, you can apply the algorithms to your container.

Algorithms

The ranges library algorithms are lazy, operate directly on the container and can be composed.

Ranges

C++ inherits the numeric functions from C and has a random number library.

Numeric

A string is a sequence of characters. C++ has many member functions to analyze or to change a string. C++-strings are the safe replacement for C Strings: const char* . Strings need the header  .

Strings

A string view is a non-owning reference to a string. It represents a view of a sequence of characters. This sequence of characters can be a C++-string or a C-string. A string view needs the header  .

String Views

Regular expression is a language for describing text patterns. They need the header  .

Regular Expressions

The input and output streams enable you to communicate with the outside world. A stream is an infinite character stream on which you can push or pull data. Push is called writing, pull is called reading.

Input and Output Streams

The formatting library provides a safe and extensible alternative to the printf family and extends the Input and Output streams. The library requires the  and the format string syntax follows the Python syntax.

Formatting Library

The new filesystem is based on boost::filesystem . Some of its components are optional. This means not all functionality of std::filesytem is available on each implementation of the filesystem library. For example, FAT-32 does not support symbolic links.

Filesystem

For the first time with C++11, C++ supports native multithreading. This support consists of two parts: A well-defined memory model and a standardized threading interface.

Multithreading

We don’t get with C++20 concrete coroutines; we have with C++20 a framework for implementing coroutines. To use concrete coroutines, you have to wait for C++23 or use the cppcoro library from Lewis Baker. Consequently, this chapter gives you only a rough idea of coroutines.

The C++ Standard Library

About the course

Author

Course Outline

Reviews