Mastering the C++17 STL · Make Full Use of the Standard Library Components in C++17 by O'Dwyer, Arthur -- Read -- Imperial Library of Trantor

Index

Preface

What this book covers What you need for this book Who this book is for Conventions Reader feedback Customer support

Downloading the example code Errata Piracy Questions

Classical Polymorphism and Generic Programming

Concrete monomorphic functions Classically polymorphic functions Generic programming with templates Summary

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

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 notion of ownership The simplest container: std::array<T, N> The workhorse: std::vector<T>

Resizing a std::vector Inserting and erasing in a std::vector Pitfalls with vector<bool> Pitfalls with non-noexcept move constructors

The speedy hybrid: std::deque<T> A particular set of skills: std::list<T>

What are the special skills of std::list?

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>

A note about transparent comparators

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

Moving elements without moving them

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

Load factor and bucket lists

Where does the memory come from? Summary

Vocabulary Types

The story of std::string Tagging reference types with reference_wrapper C++11 and algebraic types Working with std::tuple

Manipulating tuple values A note about named classes

Expressing alternatives with std::variant

Visiting variants What about make_variant? and a note on value semantics

Delaying initialization with std::optional Revisiting variant Infinite alternatives with std::any

std::any versus polymorphic class types

Type erasure in a nutshell

std::any and copyability

Again with the type erasure: std::function

std::function, copyability, and allocation

Summary

Smart Pointers

The origins of smart pointers Smart pointers never forget Automatically managing memory with std::unique_ptr<T>

Why C++ doesn't have the finally keyword Customizing the deletion callback Managing arrays with std::unique_ptr<T[]>

Reference counting with std::shared_ptr<T>

Don't double-manage! Holding nullable handles with weak_ptr Talking about oneself with std::enable_shared_from_this The Curiously Recurring Template Pattern A final warning

Denoting un-special-ness with observer_ptr<T> Summary

Concurrency

The problem with volatile Using std::atomic<T> for thread-safe accesses

Doing complicated operations atomically Big atomics

Taking turns with std::mutex

"Taking locks" the right way

Always associate a mutex with its controlled data Special-purpose mutex types

Upgrading a read-write lock Downgrading a read-write lock

Waiting for a condition Promises about futures Packaging up tasks for later The future of futures Speaking of threads...

Identifying individual threads and the current thread

Thread exhaustion and std::async Building your own thread pool

Improving our thread pool's performance

Summary

Allocators

An allocator is a handle to a memory resource

Refresher - Interfaces versus concepts

Defining a heap with memory_resource Using the standard memory resources

Allocating from a pool resource

The 500 hats of the standard allocator

Carrying metadata with fancy pointers

Sticking a container to a single memory resource Using the standard allocator types

Setting the default memory resource

Making a container allocator-aware Propagating downwards with scoped_allocator_adaptor

Propagating different allocators

Summary

Iostreams

The trouble with I/O in C++ Buffering versus formatting Using the POSIX API Using the standard C API

Buffering in the standard C API Formatting with printf and snprintf

The classical iostreams hierarchy

Streaming and manipulators Streaming and wrappers Solving the sticky-manipulator problem Formatting with ostringstream A note on locales

Converting numbers to strings Converting strings to numbers Reading a line or word at a time Summary

Regular Expressions

What are regular expressions?

A note on backslash-escaping

Reifying regular expressions into std::regex objects Matching and searching

Pulling submatches out of a match Converting submatches to data values

Iterating over multiple matches Using regular expressions for string replacement A primer on the ECMAScript regex grammar

Non-consuming constructs Obscure ECMAScript features and pitfalls

Summary

Random Numbers

Random numbers versus pseudo-random numbers The problem with rand() Solving problems with <random> Dealing with generators

Truly random bits with std::random_device Pseudo-random bits with std::mt19937 Filtering generator outputs with adaptors

Dealing with distributions

Rolling dice with uniform_int_distribution Generating populations with normal_distribution Making weighted choices with discrete_distribution Shuffling cards with std::shuffle

Summary

Filesystem

A note about namespaces A very long note on error-reporting

Using <system_error> Error codes and error conditions Throwing errors with std::system_error

Filesystems and paths

Representing paths in C++ Operations on paths

Statting files with directory_entry Walking directories with directory_iterator

Recursive directory walking

Modifying the filesystem Reporting disk usage Summary

← Prev
Back
Next →

← Prev
Back
Next →