Mastering the C++17 STL电子书

Title Page

Copyright

Mastering the C++17 STL

Credits

About the Author

About the Reviewer

www.PacktPub.com

Why subscribe?

Customer Feedback

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