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.

Related Content you might be interested in

Current Title:

Small book image
Mastering the C++17 STL
Arthur O'Dwyer
Sep, 2017 | 384 pages
No titles found
Table of Contents (13 chapters)
Preface
Preface
What this book covers
What you need for this book
Who this book is for
Conventions
Reader feedback
Customer support
Free Chapter
1
Classical Polymorphism and Generic Programming
Classical Polymorphism and Generic Programming
Concrete monomorphic functions
Classically polymorphic functions
Generic programming with templates
Summary
2
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
3
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
4
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
5
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
6
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
7
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
8
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
9
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
10
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
11
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
12
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

Allocators

We've seen in the preceding chapters that C++ has a love-hate relationship with dynamic memory allocation.

On one hand, dynamic memory allocation from the heap is a "code smell"; chasing pointers can hurt a program's performance, the heap can be exhausted unexpectedly (leading to exceptions of type std::bad_alloc), and manual memory management is so subtly difficult that C++11 introduced several different "smart pointer" types to manage the complexity (see Chapter 6, Smart Pointers). Successive versions of C++ after 2011 have also added a great number of non-allocating algebraic data types, such as tuple, optional, and variant (see Chapter 5, Vocabulary Types) that can express ownership or containment without ever touching the heap.

On the other hand, the new smart pointer types do effectively manage the complexity of memory management...

Previous Section
End of Section 1
Next Section