9.1 Introduction

No significant program is written in just a bare programming language. First, a set of libraries is developed. These then form the basis for further work. Most programs are tedious to write in the bare language, whereas just about any task can be rendered simple by the use of good libraries.

Continuing from Chapters 1–8, Chapters 9–18 give a quick tour of key standard-library facilities. I very briefly present useful standard-library types, such as string, ostream, variant, vector, map, path, unique_ptr, thread, regex, system_clock, time_zone, and complex, as well as the most common ways of using them.

As in Chapters 1–8, you are strongly encouraged not to be distracted or discouraged by an incomplete understanding of details. The purpose of this chapter is to convey a basic understanding of the most useful library facilities.

The specification of the standard library is over two thirds of the ISO C++ standard. Explore it, and prefer it to home-made alternatives. Much thought has gone into its design, more still into its implementations, and much effort will go into its maintenance and extension.

The standard-library facilities described in this book are part of every complete C++ implementation. In addition to the standard-library components, most implementations offer “graphical user interface” systems (GUIs), Web interfaces, database interfaces, etc. Similarly, most application-development environments provide “foundation libraries” for corporate or industrial “standard” development and/or execution environments. Beyond that, there are many thousands of libraries supporting specialized application areas. Here, I do not describe libraries, systems, or environments beyond the standard-libraries. The intent is to provide a self-contained description of C++ as defined by its standard [C++,2020] and to keep the examples portable. Naturally, a programmer is encouraged to explore the more extensive facilities available on most systems.

9.2 Standard-Library Components

The facilities provided by the standard library can be classified like this:

• Run-time language support (e.g., for allocation, exceptions, and run-time type information).

• The C standard library (with very minor modifications to minimize type system violations).

• Strings with support for international character sets, localization, and read-only views of substrings (§10.2).

• Support for regular expression matching (§10.4).

• I/O streams is an extensible framework for input and output to which users can add their own types, streams, buffering strategies, locales, and character sets (Chapter 11). It also offers facilities for flexible output formatting (§11.6.2).

• A library for manipulating file systems in a portable manner (§11.9).

• A framework of containers (such as vector and map; Chapter 12) and algorithms (such as find(), sort(), and merge(); Chapter 13). This framework, conventionally called the STL [Stepanov,1994], is extensible so users can add their own containers and algorithms.

• Ranges (§14.1), including views (§14.2), generators (§14.3), and pipes (§14.4).

• Concepts for fundamental types and ranges (§14.5).

• Support for numerical computation, such as standard mathematical functions, complex numbers, vectors with arithmetic operations, mathematical constants, and random-number generators (§5.2.1 and Chapter 16).

• Support for concurrent programming, including threads and locks (Chapter 18). The concurrency support is foundational so that users can add support for new models of concurrency as libraries.

• Synchronous and asynchronous coroutines (§18.6).

• Parallel versions of most STL algorithms and of some numerical algorithms, such as sort() (§13.6) and reduce() (§17.3.1).

• Utilities to support metaprogramming (e.g., type functions; §16.4), STL-style generic programming (e.g., pair; §15.3.3), and general programming (e.g., variant and optional; §15.4.1, §15.4.2).

• “Smart pointers” for resource management (e.g., unique_ptr and shared_ptr; §15.2.1).

• Special-purpose containers, such as array (§15.3.1), bitset (§15.3.2), and tuple (§15.3.3).

• Support for absolute time and durations, e.g., time_point and system_clock (§16.2.1).

• Support for calendars, e.g., month and time_zone (§16.2.2, §16.2.3).

• Suffixes for popular units, such as ms for milliseconds and i for imaginary (§6.6).

• Ways of manipulating sequences of elements, such as views (§14.2), string_views (§10.3), and spans (§15.2.2).

The main criteria for including a class in the library were that:

• It could be helpful to almost every C++ programmer (both novices and experts).

• It could be provided in a general form that did not add significant overhead compared to a simpler version of the same facility.

• Simple uses should be easy to learn (relative to the inherent complexity of their task).

Essentially, the C++ standard library provides the most common fundamental data structures together with the fundamental algorithms used on them.

9.3 Standard-Library Organization

The facilities of the standard library are placed in namespace std and made available to users through modules or headed files.

#include<string>
#include<list>

std::string sheep {"Four legs Good; two legs Baaad!"};
std::list<std::string> slogans {"War is Peace", "Freedom is Slavery", "Ignorance is Strength"};

#include<string>                     // make the standard string facilities accessible
using namespace std;            // make std names available without std:: prefix

string s {"C++ is a general-purpose programming language"};      // OK: string is std::string

// no mention of complex_literals
auto z1 = 2+3i;          // error: no suffix 'i'

using namespace literals::complex_literals; // make the complex literals visible
auto z2 = 2+3i;          // ok: z2 is a complex<double>

using namespace std;
using namespace ranges;

void f(vector<int>& v)
{
        sort(v.begin(),v.end());       // error:ambiguous
        sort(v);                                // error: ambiguous
}

using namespace std;

void g(vector<int>& v)
{
        sort(v.begin(),v.end());     // OK
        sort(v);                              // error: no matching function (in std)
        ranges::sort(v);               // OK
        using ranges::sort;         // sort(v) OK from here on
        sort(v);                             // OK
}

9.4 Advice

[1] Don’t reinvent the wheel; use libraries; §9.1; [CG: SL.1.]

[2] When you have a choice, prefer the standard library over other libraries; §9.1; [CG: SL.2].

[3] Do not think that the standard library is ideal for everything; §9.1.

[4] If you don’t use modules, remember to #include the appropriate headers; §9.3.1.

[5] Remember that standard-library facilities are defined in namespace std; §9.3.1; [CG: SL.3].

[6] When using ranges, remember to explicitly qualify algorithm names; §9.3.2.

[7] Prefer importing modules over #includeing header files (§9.3.3).