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

Smart Pointers

C++ holds its grip on large swaths of the software industry by virtue of its performance--well-written C++ code runs faster than anything else out there, almost by definition, because C++ gives the programmer almost complete control over the code that is ultimately generated by the compiler.

One of the classic features of low-level, performant code is the use of raw pointers (Foo*). However, raw pointers come with many pitfalls, such as memory leaks and dangling pointers. The C++11 library's "smart pointer" types can help you avoid these pitfalls at little to no expense.

In this chapter we'll learn the following:

  • The definition of "smart pointer" and how you might write your own
  • The usefulness of std::unique_ptr<T> in preventing resource leaks of all types (not just memory leaks)
  • How std::shared_ptr<T> is implemented, and...
Previous Section
End of Section 1
Next Section