Advanced C++ 17 STL Training Objectives

Key Point of Training Programs

• Advanced C++ 17 STL Prerequisites

  Must be a competent C++ Programmer

• Advanced C++ 17 STL Training Format

  In-Person

  Online

• Advanced C++ 17 STL Outline

  1: 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

  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

  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

  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

  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

  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

  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

  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

  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

  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