Book Image

Mastering the C++17 STL

By : Arthur O'Dwyer

Book Image

Mastering the C++17 STL

By: Arthur O'Dwyer

Overview of this book

Modern C++ has come a long way since 2011. The latest update, C++17, has just been ratified and several implementations are on the way. This book is your guide to the C++ standard library, including the very latest C++17 features. The book starts by exploring the C++ Standard Template Library in depth. You will learn the key differences between classical polymorphism and generic programming, the foundation of the STL. You will also learn how to use the various algorithms and containers in the STL to suit your programming needs. The next module delves into the tools of modern C++. Here you will learn about algebraic types such as std::optional, vocabulary types such as std::function, smart pointers, and synchronization primitives such as std::atomic and std::mutex. In the final module, you will learn about C++'s support for regular expressions and file I/O. By the end of the book you will be proficient in using the C++17 standard library to implement real programs, and you'll have gained a solid understanding of the library's own internals.

Preface

What this book covers

What you need for this book

Who this book is for

Reader feedback

Customer support

Free Chapter

Classical Polymorphism and Generic Programming

Classical Polymorphism and Generic Programming

Concrete monomorphic functions

Classically polymorphic functions

Generic programming with templates

Iterators and Ranges

Iterators and Ranges

The problem with integer indices

On beyond pointers

Const iterators

A pair of iterators defines a range

Iterator categories

Input and output iterators

Putting it all together

The deprecated std::iterator

The Iterator-Pair Algorithms

The Iterator-Pair Algorithms

A note about headers

Read-only range algorithms

Shunting data with std::copy

Variations on a theme - std::move and std::move_iterator

Complicated copying with std::transform

Write-only range algorithms

Algorithms that affect object lifetime

Our first permutative algorithm: std::sort

Swapping, reversing, and partitioning

Rotation and permutation

Heaps and heapsort

Merges and mergesort

Searching and inserting in a sorted array with std::lower_bound

Deleting from a sorted array with std::remove_if

The Container Zoo

The Container Zoo

The notion of ownership

The simplest container: std::array<T, N>

The workhorse: std::vector<T>

The speedy hybrid: std::deque<T>

A particular set of skills: std::list<T>

Roughing it with std::forward_list<T>

Abstracting with std::stack<T> and std::queue<T>

The useful adaptor: std::priority_queue<T>

The trees: std::set<T> and std::map<K, V>

Oddballs: std::multiset<T> and std::multimap<K, V>

The hashes: std::unordered_set<T> and std::unordered_map<K, V>

Where does the memory come from?

Vocabulary Types

Vocabulary Types

The story of std::string

Tagging reference types with reference_wrapper

C++11 and algebraic types

Working with std::tuple

Expressing alternatives with std::variant

Delaying initialization with std::optional

Revisiting variant

Infinite alternatives with std::any

Type erasure in a nutshell

Again with the type erasure: std::function

Smart Pointers

The origins of smart pointers

Smart pointers never forget

Automatically managing memory with std::unique_ptr<T>

Reference counting with std::shared_ptr<T>

Denoting un-special-ness with observer_ptr<T>

Concurrency

The problem with volatile

Using std::atomic<T> for thread-safe accesses

Taking turns with std::mutex

Always associate a mutex with its controlled data

Special-purpose mutex types

Waiting for a condition

Promises about futures

Packaging up tasks for later

The future of futures

Speaking of threads...

Thread exhaustion and std::async

Building your own thread pool

Allocators

An allocator is a handle to a memory resource

Defining a heap with memory_resource

Using the standard memory resources

The 500 hats of the standard allocator

Sticking a container to a single memory resource

Using the standard allocator types

Making a container allocator-aware

Propagating downwards with scoped_allocator_adaptor

Iostreams

The trouble with I/O in C++

Buffering versus formatting

Using the POSIX API

Using the standard C API

The classical iostreams hierarchy

Converting numbers to strings

Converting strings to numbers

Reading a line or word at a time

Regular Expressions

Regular Expressions

What are regular expressions?

Reifying regular expressions into std::regex objects

Matching and searching

Iterating over multiple matches

Using regular expressions for string replacement

A primer on the ECMAScript regex grammar

Random Numbers

Random numbers versus pseudo-random numbers

The problem with rand()

Solving problems with <random>

Dealing with generators

Dealing with distributions

Filesystem

A note about namespaces

A very long note on error-reporting

Filesystems and paths

Statting files with directory_entry

Walking directories with directory_iterator

Modifying the filesystem

Reporting disk usage

Customer Reviews

5 star

0

4 star

0

3 star

0

2 star

0

1 star

0

Summary

In this chapter we've learned the following: A container manages the ownership of a collection of elements. STL containers are always class templates parameterized on the element type, and sometimes on other relevant parameters as well. Every container except std::array<T, N> can be parameterized by an allocator type to specify the manner in which it allocates and deallocates memory. Containers that use comparison can be parameterized by a comparator type. Consider using transparent comparator types such as std::less<> instead of homogeneous comparators.

When using std::vector, watch out for reallocation and address invalidation. When using most container types, watch out for iterator invalidation.

The standard library's philosophy is to support no operation that is naturally inefficient (such as vector::push_front); and to support any operation that...