Sign In Start Free Trial

Mastering the C++17 STL

By : Arthur O'Dwyer

4.5 (11)

Mastering the C++17 STL

4.5 (11)

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

Preface

What this book covers

What you need for this book

Who this book is for

Conventions

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

Summary

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

Summary

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

Summary

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?

Summary

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

Summary

Smart Pointers

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>

Summary

Concurrency

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

Summary

Allocators

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

Summary

Iostreams

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

Summary

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

Summary

Random Numbers

Random Numbers

Random numbers versus pseudo-random numbers

The problem with rand()

Solving problems with <random>

Dealing with generators

Dealing with distributions

Summary

Filesystem

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

Summary

Customer Reviews

4.5 (11)

5 star

63.6%

4 star

27.3%

3 star

9.1%

2 star

0

1 star

0

Summary

Allocators are a fundamentally arcane topic in C++, mainly for historical reasons. Several different interfaces, with different obscure use-cases, are piled one on top of the other; all of them involve intense metaprogramming; and vendor support for many of these features, even relatively old C++11 features such as fancy pointers, is still lacking.

C++17 offers the standard library type std::pmr::memory_resource to clarify the existing distinction between memory resources (a.k.a. heaps) and allocators (a.k.a. handles to heaps). Memory resources provide allocate and deallocate methods; allocators provide those methods as well as construct and destroy.

If you implement your own allocator type A, it must be a template; its first template parameter should be the type T that it expects to allocate. Your allocator type A must also have a templated constructor to support &quot...

Search

Your notes and bookmarks