Concurrent Programming with Threads and Locks

The C++ standard library is large. It offers facilities for memory allocation, text handling, input and output, data collections, mathematics, concurrency, and more. Meeting this collection for the first time can be overwhelming, because the individual names do not explain how they relate to one another. Seeing a list of names gives you no sense of which ones matter together or which ones are needed before others.

The standard library addresses this in its own documentation by classifying its facilities into groups. Once you know the groups, a new facility has a place in your mental map, and you can predict roughly what it is for before you read its details. This article follows that classification. The goal is not to memorize every facility. The goal is to build a picture of the whole library that you can return to as you learn each part in detail.

Before reading the groups, pause and try a short exercise. Imagine you are designing a library that programs could build on. What kinds of help would you expect it to offer? Keep your answer in mind, then compare it with the categories described below. You will notice that many of your expectations appear in the list, and a few may surprise you.

The source describes the standard library as a set of facilities that can be classified into eleven groups. They are run-time language support, the C standard library, strings, regular expression matching, I/O streams, containers and algorithms, numerical computation, concurrent programming, template metaprogramming, smart pointers, and special-purpose containers. Each group answers a different kind of need. Some groups support the language machinery underneath every program, some support handling text and data, and some support building larger or more general code.

Read the diagram as a map, not as a stack. Each group is a separate kind of support that the library offers. The groups are not layered so that one must sit on top of another, so you should not infer a required order of use from the picture. The grouping is useful because it tells you where to look when you need a kind of help.

The first two categories form the foundation on which the rest of the library rests. The first is run-time language support. It provides facilities for allocation and for run-time type information. Allocation is the act of obtaining memory while a program runs. Run-time type information lets a program inspect type information while it executes. These are facilities the language needs in order to operate, which is why they are grouped first. You rarely make them the main topic of a program, but many other facilities depend on them.

The second foundational category is the C standard library. The source states that it is included in the C++ standard library with very minor modifications, and those modifications exist to minimize violations of the type system. This tells you something about the design. The C++ library did not discard the older C facilities. It adapted them so that they fit the stricter type rules of C++ as closely as possible.

Many programs spend much of their time working with text, so the standard library groups three related kinds of support together. These categories are all about how a program reads, represents, and searches character data. They are presented separately because each one answers a different question. Strings answer how text is stored and handled. Regular expression matching answers how patterns are found inside text. I/O streams answer how data moves in and out of a program.

Keeping these three apart makes classification easier. If your question is about the shape of a piece of text, you are looking at strings. If your question is about finding a pattern such as a particular format inside text, you are looking at regular expression matching. If your question is about reading from or writing to the outside world, you are looking at I/O streams.

The next two categories cover organizing data and computing with it. Containers and algorithms, which the source identifies with the STL, handle data organization. Numerical computation covers mathematical work. Both categories are large and important, and both are used constantly, which is why they are often the first parts of the library that programmers learn in depth.

Containers and algorithms are often used together. A program might hold a collection of values in a container and then process those values with an algorithm. The classification keeps these two roles distinct: the container is where the data lives, and the algorithm is what is done with it.

The last three categories in the classification address more advanced concerns. Concurrent programming addresses running work at the same time. Template metaprogramming addresses writing code that works across many types. Smart pointers address managing resources so that they are handled correctly. Each is a distinct category with its own purpose, and none of them is simply a variation of another.

The final category is special-purpose containers. The source lists three: array, bitset, and tuple. All three are containers, but the word special-purpose signals that each serves a narrower role than the general containers of the STL. Treat them as a set of distinct tools rather than one idea. Knowing that they are containers tells you they hold data. Knowing that they are special-purpose tells you that their role is narrower than the general containers.

Two broad roles appear across the eleven groups. Some facilities exist so the language can operate at all. Others exist so that programmers can do ordinary work. The table below sets these two roles side by side, so you can see how the groups divide.

Groups are not exclusive. A program may use facilities from several groups at once. Consider a simple task in which a program reads text, keeps it, and then works on it. Each step can be matched to a group, and the flow runs from left to right.

Beginners tend to make a few predictable errors when they use the classification. Each one is easy to correct once you know what to look for.

The classification of the library into groups gives you a map before you learn each part in detail. When you meet a new facility, place its purpose on the map first, then move to its details. The map is what lets you predict what a facility is for before you read about it.