1: STARTING TO WRITE YOUR APPLICATION
Introduction
Getting configuration options
Storing any value in a container/variable
Storing multiple chosen types in a container/variable
Using a safer way to work with a container that stores multiple chosen types
Returning a value or flag where there is no value
Returning an array from a function
Combining multiple values into one
Binding and reordering function parameters
Getting a human-readable type name
Using the C++11 move emulation
Making a noncopyable class
Making a noncopyable but movable class
Using C++14 and C++11 algorithms

2: MANAGING RESOURCES
Introduction
Managing local pointers to classes that do not leave scope
Reference counting of pointers to classes used across functions
Managing pointers to arrays that do not leave scope
Reference counting of pointers to arrays used across functions
Storing any functional objects in a variable
Passing function pointer in a variable
Passing C++11 lambda functions in a variable
Containers of pointers
Do it at scope exit!
Initializing the base class by the member of the derived class

3: CONVERTING AND CASTING
Introduction
Converting strings to numbers
Converting numbers to strings
Converting numbers to numbers
Converting user-defined types to/from strings
Converting smart pointers
Casting polymorphic objects
Parsing simple input
Parsing complex input

4: COMPILE-TIME TRICKS
Introduction
Checking sizes at compile time
Enabling function template usage for integral types
Disabling function template usage for real types
Creating a type from a number
Implementing a type trait
Selecting an optimal operator for a template parameter
Getting a type of expression in C++03

5: MULTITHREADING
Introduction
Creating a thread of execution
Syncing access to a common resource
Fast access to common resource using atomics
Creating work_queue class
Multiple-readers-single-writer lock
Creating variables that are unique per thread
Interrupting a thread
Manipulating a group of threads
Initializing a shared variable safely
Locking multiple mutexes

6: MANIPULATING TASKS
Introduction
Registering a task for an arbitrary data type processing
Making timers and processing timer events as tasks
Network communication as a task
Accepting incoming connections
Executing different tasks in parallel
Pipeline tasks processing
Making a nonblocking barrier
Storing an exception and making a task from it
Getting and processing system signals as tasks

7: MANIPULATING STRINGS
Introduction
Changing cases and case-insensitive comparison
Matching strings using regular expressions
Searching and replacing strings using regular expressions
Formatting strings using safe printf-like functions
Replacing and erasing strings
Representing a string with two iterators
Using a reference to string type

8: METAPROGRAMMING
Introduction
Using type vector of types
Manipulating a vector of types
Getting a function's result type at compile time
Making a higher-order metafunction
Evaluating metafunctions lazily
Converting all the tuple elements to strings
Splitting tuples
Manipulating heterogeneous containers in C++14

9: CONTAINERS
Introduction
Storing a few elements in a sequence container
Storing at most N elements in the sequence container
Comparing strings in an ultra-fast manner
Using an unordered set and map
Making a map, where value is also a key
Using multi-index containers
Getting benefits of a single linked list and memory pool
Using flat associative containers

10: GATHERING PLATFORM AND COMPILER INFORMATION
Introduction
Detecting an OS and compiler
Detecting int128 support
Detecting and bypassing disabled RTTI
Writing metafunctions using simpler methods
Reducing code size and increasing performance of user-defined types (UDTs) in C++11
The portable way to export and import functions and classes
Detecting the Boost version and getting latest features

11: WORKING WITH THE SYSTEM
Introduction
Listing files in a directory
Erasing and creating files and directories
Writing and using plugins
Getting backtrace - current call sequence
Passing data quickly from one process to another
Syncing interprocess communications
Using pointers in a shared memory
The fastest way to read files
Coroutines - saving the state and postponing the execution

12: SCRATCHING THE TIP OF THE ICEBERG
Introduction
Working with graphs
Visualizing graphs
Using a true random number generator
Using portable math functions
Writing test cases
Combining multiple test cases in one test module
Manipulating images