C++17 STL Cookbook

C++17 STL Cookbook

By : Jacek Galowicz

Buy this Book

C++17 STL Cookbook

By: Jacek Galowicz

Buy this Book

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.

Title Page

Credits

About the Author

About the Reviewer

www.PacktPub.com

Customer Feedback

Preface

Free Chapter

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

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

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

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

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

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

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

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

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

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

Customer Reviews

5 star

4 star

3 star

2 star

1 star

Automatically checking iterator code with checked iterators

No matter how useful iterators are, and what generic interface they represent, iterators can easily be misused, just as pointers. When dealing with pointers, code must be written in a way that it never dereferences them when they point to invalid memory locations. Same applies to iterators, but there are a lot of rules that state when an iterator is valid and when it is invalidated. Those can easily be learned by studying the STL documentation a bit, but it will still always be possible to write buggy code.

In the best case, such buggy code blows up in front of the developer while it is being tested, and not on the client's machine. However, in many cases, the code just silently seems to work, although it dereferences dangling pointers, iterators, and so on. In such cases, we want to be eagerly alarmed if we produce code showing undefined behavior.

Fortunately, there's help! The GNU STL implementation has a debug mode, and the GNU...

C++17 STL Cookbook

By : Jacek Galowicz

C++17 STL Cookbook

By: Jacek Galowicz

Overview of this book

Related Content you might be interested in

Current Title:

C++17 STL Cookbook

C++20 STL Cookbook

The C++ Standard Library

Data Structures and Algorithms with the C++ STL

Automatically checking iterator code with checked iterators