Lesson 9: Library Overview

Lesson 0009 — A Tour of C++, Chapter 9 (§9.1–§9.4)

Chapters 1–8 built the language from first principles: types, classes, templates, concepts. But no significant program is written in a bare programming language — "first, a set of libraries is developed. These then form the basis for further work." This chapter is the pivot of the book: a tour of the standard library, whose specification is over two thirds of the ISO C++ standard. It classifies what the library offers (strings, I/O streams, containers, algorithms, ranges, numerics, concurrency, smart pointers…), and shows how it's organized: everything lives in namespace std, delivered through headers (soon modules), with literal suffixes quarantined in sub-namespaces and range-versions of algorithms kept separate from the iterator-pair versions.

9.1 Introduction — Why Libraries

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. Chapters 9–18 give a quick tour of key standard-library facilities: string, ostream, variant, vector, map, path, unique_ptr, thread, regex, system_clock, time_zone, and complex. As in Chapters 1–8, don't be distracted or discouraged by incomplete understanding of details — the goal is a basic understanding of the most useful facilities.

Three selection criteria governed whether a class was included in the standard library:

• It could be helpful to almost every C++ programmer, novice or expert.
• 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. The standard-library facilities are part of every complete C++ implementation — and beyond them lie GUIs, web interfaces, database interfaces, and thousands of specialized libraries, none of which this book describes. The intent is a self-contained, portable description of C++ as defined by its standard [C++, 2020].

9.2 Standard-Library Components

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

• Run-time language support — allocation, exceptions, run-time type information.
• The C standard library, with very minor modifications to minimize type-system violations.
• Strings with international character set support, localization, and read-only views of substrings (§10.2–§10.3).
• Regular expression matching (§10.4).
• I/O streams — an extensible input/output framework users can extend with their own types, streams, buffering strategies, locales, and character sets (Chapter 11), plus flexible output formatting (§11.6.2).
• File systems, manipulated portably (§11.9).
• The STL framework of containers (vector, map; Chapter 12) and algorithms (find(), sort(), merge(); Chapter 13) [Stepanov, 1994] — 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).
• Numerical computation — standard math functions, complex numbers, vectors with arithmetic operations, mathematical constants, random-number generators (§16–§17).
• Concurrent programming — threads and locks (Chapter 18), foundational so users can add new concurrency models as libraries; plus synchronous and asynchronous coroutines (§18.6).
• Parallel versions of most STL algorithms and some numerical ones, such as sort() (§13.6) and reduce() (§17.3.1).
• Metaprogramming utilities (type functions; §16.4), STL-style generic programming (pair; §15.3.3), and general programming (variant, optional; §15.4).
• "Smart pointers" for resource management — unique_ptr, shared_ptr (§15.2.1).
• Special-purpose containers — array (§15.3.1), bitset (§15.3.2), tuple (§15.3.3).
• Time and calendars — time_point, system_clock (§16.2.1), month, time_zone (§16.2.2–§16.2.3).
• Unit suffixes — ms for milliseconds, i for imaginary (§6.6).
• Sequence manipulation — views (§14.2), string_views (§10.3), spans (§15.2.2).

In one sentence: the standard library provides the most common fundamental data structures and the fundamental algorithms used on them, each checked against the three inclusion criteria above.

9.3 Standard-Library Organization

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

9.3.1 Namespaces

Every standard-library facility is provided through some standard header:

#include <string>   // the standard string
#include <list>     // the standard list

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

The library is defined in the namespace std (§3.3). You can use the std:: prefix, or — at some cost in taste — bring the names in:

#include <string>
using namespace std;   // make std names available without std:: prefix
string s {"C++ is a general-purpose programming language"};   // OK: string is std::string

It is generally in poor taste to dump every name from a namespace into the global namespace — but the book does it for brevity, and it's good to know what the library offers.

The standard library offers several sub-namespaces that can be accessed only through an explicit action:

To use a suffix from a sub-namespace, you must introduce it into the namespace where you want to use it:

// 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>

Why sub-namespaces at all? Suffixes cannot be explicitly qualified (you can't write chrono_literals::s — a suffix is only usable after a literal), so the only way to use one is to bring in a whole set. Placing them in sub-namespaces means you can bring in one set of suffixes into a scope without risking ambiguities with another library's suffixes.

9.3.2 The ranges namespace

The standard library offers algorithms such as sort() and copy() in two versions:

• A traditional sequence version taking a pair of iterators — e.g., sort(begin(v), v.end()).
• A range version taking a single range — e.g., sort(v).

Ideally these would overload perfectly without special effort — but they don't. Naively bringing in both namespaces makes both calls ambiguous:

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

To protect against ambiguities with the traditional unconstrained templates, the standard requires that you explicitly introduce the range version of an algorithm into a scope:

using namespace std;
void g(vector<int>& v) {
    sort(v.begin(), v.end());   // OK (the std iterator-pair version)
    sort(v);                    // error: no matching function (in std)
    ranges::sort(v);            // OK (explicitly qualified)
    using ranges::sort;         // from here on:
    sort(v);                    // OK (resolves to the range version)
}

9.3.3 Modules

There are not yet any standard-library modules — a gap caused by lack of committee time, likely remedied in C++23. The book uses a hypothetical import std; module that would offer all facilities from namespace std (see Appendix A). The advice: prefer importing modules over #includeing header files when they become available — modules are semi-compiled and fast to import (§8.5).

9.3.4 Headers

Here is a selection of standard-library headers, all supplying declarations in namespace std:

This listing is far from complete. Headers from the C standard library (like <stdlib.h>) are provided too — and for each, there is a version with the name prefixed by c and the .h removed. That version (<cstdlib>) places its declarations in both the std and global namespaces. The headers reflect the history of the library's development, so they aren't always as logical and easy to remember as we'd like — one reason to use a module such as std (§9.3.3) instead.

9.4 Advice

Here is a summary of the guidance from this chapter. All 7 items, with the section where each is introduced. The C++ Core Guidelines link each item to its recommended practice.

Retrieval Quiz

Notes

Primary source: Stroustrup, B. (2022). A Tour of C++, 3rd ed., Chapter 9: "Library Overview." Addison-Wesley.
Reference: Chapter 1–9 Quick Reference & Glossary — keep it beside you while you study.
Recommended supplement: cppreference on standard library headers, ranges library, namespaces, and user-defined literals.

Questions? Ask your agent — your teacher — about anything unclear: how the ranges versions coexist with the traditional algorithms, when a sub-namespace is warranted, or which header provides what. Follow-ups are expected, not optional.

Chapters

1. Lesson 1: The Basics (Ch. 1)
2. Lesson 2: User-Defined Types (Ch. 2)
3. Lesson 3: Separate Compilation (Ch. 3)
4. Lesson 4: Error Handling (Ch. 4)
5. Lesson 5: Classes (Ch. 5)
6. Lesson 6: Essential Operations (Ch. 6)
7. Lesson 7: Templates (Ch. 7)
8. Lesson 8: Concepts and Generic Programming (Ch. 8)
9. Lesson 9: Library Overview (Ch. 9 — this lesson)
10. Lesson 10: Strings and Regular Expressions (Ch. 10)
11. Lesson 11: Input and Output (Ch. 11)
12. Lesson 12: Containers (Ch. 12)
13. Lesson 13: Algorithms (Ch. 13)
14. Lesson 14: Ranges (Ch. 14)
15. Lesson 15: Pointers and Containers (Ch. 15)
16. Lesson 16: Utilities (Ch. 16)
17. Lesson 17: Numerics (Ch. 17)
18. Lesson 18: Concurrency (Ch. 18)
19. Lesson 19: History and Compatibility (Ch. 19)