Boost C++ Application Development Cookbook

Table of Contents

• Preface

• Chapter 1: Starting to Write Your Application
• Introduction
• Getting configuration options
• Storing any value in a container/variable
• Storing multiple chosen types in a variable/container
• 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
• Reordering the parameters of function
• Binding a value as a function parameter
• Using the C++11 move emulation
• Making a noncopyable class
• Making a noncopyable but movable class

• Chapter 2: Converting Data
• Introduction
• Converting strings to numbers
• Converting numbers to strings
• Converting numbers to numbers
• Converting user-defined types to/from strings
• Casting polymorphic objects
• Parsing simple input
• Parsing input

• Chapter 3: Managing Resources
• Introduction
• Managing pointers to classes that do not leave scope
• Reference counting of pointers to classes used across methods
• Managing pointers to arrays that do not leave scope
• Reference counting pointers to arrays used across methods
• Storing any functional objects in a variable
• Passing a function pointer in a variable
• Passing C++11 lambda functions in a variable
• Containers of pointers
• Doing something at scope exit
• Initializing the base class by a member of the derived class

• Chapter 4: Compile-time Tricks
• Introduction
• Checking sizes at compile time
• Enabling the usage of templated functions for integral types
• Disabling templated functions' usage for real types
• Creating a type from number
• Implementing a type trait
• Selecting an optimal operator for a template parameter
• Getting a type of expression in C++03

• Chapter 5: Multithreading
• Introduction
• Creating an execution thread
• Syncing access to a common resource
• Fast access to common resource using atomics
• Creating a work_queue class
• Multiple-readers-single-writer lock
• Creating variables that are unique per thread
• Interrupting a thread
• Manipulating a group of threads

• Chapter 6: Manipulating Tasks
• Introduction
• Registering a task for processing an arbitrary datatype
• Making timers and processing timer events as tasks
• Network communication as a task
• Accepting incoming connections
• Executing different tasks in parallel
• Conveyor tasks processing
• Making a nonblocking barrier
• Storing an exception and making a task from it
• Getting and processing system signals as tasks

• Chapter 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

• Chapter 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

• Chapter 9: Containers
• Introduction
• 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 the benefits of single-linked list and memory pool
• Using flat associative containers

• Chapter 10: Gathering Platform and Compiler Information
• Introduction
• Detecting int128 support
• Detecting RTTI support
• Speeding up compilation using C++11 extern templates
• 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

• Chapter 11: Working with the System
• Introduction
• Listing files in a directory
• Erasing and creating files and directories
• Passing data quickly from one process to another
• Syncing interprocess communications
• Using pointers in shared memory
• The fastest way to read files
• Coroutines – saving the state and postponing the execution

• Chapter 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

• Index