Book Image

C++17 STL Cookbook

By : Jacek Galowicz
Book Image

C++17 STL Cookbook

By: Jacek Galowicz

Overview of this book

C++ has come a long way and is in use in every area of the industry. Fast, efficient, and flexible, it is used to solve many problems. The upcoming version of C++ will see programmers change the way they code. If you want to grasp the practical usefulness of the C++17 STL in order to write smarter, fully portable code, then this book is for you. Beginning with new language features, this book will help you understand the language’s mechanics and library features, and offers insight into how they work. Unlike other books, ours takes an implementation-specific, problem-solution approach that will help you quickly overcome hurdles. You will learn the core STL concepts, such as containers, algorithms, utility classes, lambda expressions, iterators, and more, while working on practical real-world recipes. These recipes will help you get the most from the STL and show you how to program in a better way. By the end of the book, you will be up to date with the latest C++17 features and save time and effort while solving tasks elegantly using the STL.

Related Content you might be interested in

Current Title:

Small book image
C++17 STL Cookbook
Jacek Galowicz
Jun, 2017 | 532 pages
Small book image
C++20 STL Cookbook
William Weinman
May, 2022 | 450 pages
Small book image
The C++ Standard Library
Rainer Grimm
Dec, 2019 | 251 pages
Small book image
Data Structures and Algorithms with the C++ STL
John Farrier
Feb, 2024 | 458 pages
Table of Contents (18 chapters)
Title Page
Title Page
Credits
Credits
About the Author
About the Author
About the Reviewer
About the Reviewer
www.PacktPub.com
www.PacktPub.com
Customer Feedback
Customer Feedback
Preface
Preface
Free Chapter
1
The New C++17 Features
The New C++17 Features
Introduction
Using structured bindings to unpack bundled return values
Limiting variable scopes to if and switch statements
Profiting from the new bracket initializer rules
Letting the constructor automatically deduce the resulting template class type
Simplifying compile time decisions with constexpr-if
Enabling header-only libraries with inline variables
Implementing handy helper functions with fold expressions
2
STL Containers
STL Containers
Introduction
Using the erase-remove idiom on std::vector
Deleting items from an unsorted std::vector in O(1) time
Accessing std::vector instances the fast or the safe way
Keeping std::vector instances sorted
Inserting items efficiently and conditionally into std::map
Knowing the new insertion hint semantics of std::map::insert
Efficiently modifying the keys of std::map items
Using std::unordered_map with custom types
Filtering duplicates from user input and printing them in alphabetical order with std::set
Implementing a simple RPN calculator with std::stack
Implementing a word frequency counter with std::map
Implement a writing style helper tool for finding very long sentences in text with std::multimap
Implementing a personal to-do list using std::priority_queue
3
Iterators
Iterators
Introduction
Building your own iterable range
Making your own iterators compatible with STL iterator categories
Using iterator adapters to fill generic data structures
Implementing algorithms in terms of iterators
Iterating the other way around using reverse iterator adapters
Terminating iterations over ranges with iterator sentinels
Automatically checking iterator code with checked iterators
Building your own zip iterator adapter
4
Lambda Expressions
Lambda Expressions
Introduction
Defining functions on the run using lambda expressions
Adding polymorphy by wrapping lambdas into std::function
Composing functions by concatenation
Creating complex predicates with logical conjunction
Calling multiple functions with the same input
Implementing transform_if using std::accumulate and lambdas
Generating cartesian product pairs of any input at compile time
5
STL Algorithm Basics
STL Algorithm Basics
Introduction
Copying items from containers to other containers
Sorting containers
Removing specific items from containers
Transforming the contents of containers
Finding items in ordered and unordered vectors
Limiting the values of a vector to a specific numeric range with std::clamp
Locating patterns in strings with std::search and choosing the optimal implementation
Sampling large vectors
Generating permutations of input sequences
Implementing a dictionary merging tool
6
Advanced Use of STL Algorithms
Advanced Use of STL Algorithms
Introduction
Implementing a trie class using STL algorithms
Implementing a search input suggestion generator with tries
Implementing the Fourier transform formula with STL numeric algorithms
Calculating the error sum of two vectors
Implementing an ASCII Mandelbrot renderer
Building our own algorithm - split
Composing useful algorithms from standard algorithms - gather
Removing consecutive whitespace between words
Compressing and decompressing strings
7
Strings, Stream Classes, and Regular Expressions
Strings, Stream Classes, and Regular Expressions
Introduction
Creating, concatenating, and transforming strings
Trimming whitespace from the beginning and end of strings
Getting the comfort of std::string without the cost of constructing std::string objects
Reading values from user input
Counting all words in a file
Formatting your output with I/O stream manipulators
Initializing complex objects from file input
Filling containers from std::istream iterators
Generic printing with std::ostream iterators
Redirecting output to files for specific code sections
Creating custom string classes by inheriting from std::char_traits
Tokenizing input with the regular expression library
Comfortably pretty printing numbers differently per context on the fly
Catching readable exceptions from std::iostream errors
8
Utility Classes
Utility Classes
Introduction
Converting between different time units using std::ratio
Converting between absolute and relative times with std::chrono
Safely signalizing failure with std::optional
Applying functions on tuples
Quickly composing data structures with std::tuple
Replacing void* with std::any for more type safety
Storing different types with std::variant
Automatically handling resources with std::unique_ptr
Automatically handling shared heap memory with std::shared_ptr
Dealing with weak pointers to shared objects
Simplifying resource handling of legacy APIs with smart pointers
Sharing different member values of the same object
Generating random numbers and choosing the right random number engine
Generating random numbers and letting the STL shape specific distributions
9
Parallelism and Concurrency
Parallelism and Concurrency
Introduction
Automatically parallelizing code that uses standard algorithms
Putting a program to sleep for specific amounts of time
Starting and stopping threads
Performing exception safe shared locking with std::unique_lock and std::shared_lock
Avoiding deadlocks with std::scoped_lock
Synchronizing concurrent std::cout use
Safely postponing initialization with std::call_once
Pushing the execution of tasks into the background using std::async
Implementing the producer/consumer idiom with std::condition_variable
Implementing the multiple producers/consumers idiom with std::condition_variable
Parallelizing the ASCII Mandelbrot renderer using std::async
Implementing a tiny automatic parallelization library with std::future
10
Filesystem
Filesystem
Introduction
Implementing a path normalizer
Getting canonical file paths from relative paths
Listing all files in directories
Implementing a grep-like text search tool
Implementing an automatic file renamer
Implementing a disk usage counter
Calculating statistics about file types
Implementing a tool that reduces folder size by substituting duplicates with symlinks
Index
Index

Chapter 8. Utility Classes

In this chapter, we will cover the following recipes:

  • Converting between different time units using std::ratio
  • Converting between absolute and relative times with std::chrono
  • Safely signalizing failure with std::optional
  • Applying functions on tuples
  • Quickly composing data structures with std::tuple
  • Replacing void* with std::any for more type safety
  • Storing different types with std::variant
  • Automatically handling resources with std::unique_ptr
  • Automatically handling shared heap memory with std::shared_ptr
  • Dealing with weak pointers to shared objects
  • Simplifying resource handling of legacy APIs with smart pointers
  • Sharing different member values of the same object
  • Generating random numbers and choosing the right random number engine
  • Generating random numbers and letting the STL shape specific distributions
Previous Section
End of Section 1
Next Section