Sign In Start Free Trial

Book Overview & Buying
Table Of Contents
Feedback & Rating

Boost C++ Application Development Cookbook

By : Anton Polukhin Alekseevic

4.2 (5)

Boost C++ Application Development Cookbook

4.2 (5)

By: Anton Polukhin Alekseevic

Overview of this book

If you want to take advantage of the real power of Boost and C++ and avoid the confusion about which library to use in which situation, then this book is for you. Beginning with the basics of Boost C++, you will move on to learn how the Boost libraries simplify application development. You will learn to convert data such as string to numbers, numbers to string, numbers to numbers and more. Managing resources will become a piece of cake. You’ll see what kind of work can be done at compile time and what Boost containers can do. You will learn everything for the development of high quality fast and portable applications. Write a program once and then you can use it on Linux, Windows, MacOS, Android operating systems. From manipulating images to graphs, directories, timers, files, networking – everyone will find an interesting topic. Be sure that knowledge from this book won’t get outdated, as more and more Boost libraries become part of the C++ Standard.

Preface

Preface

What this book covers

What you need for this book

Who this book is for

Sections

Conventions

Reader feedback

Customer support

Free Chapter

Starting to Write Your Application

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

Managing Resources

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

Converting and Casting

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

Compile-Time Tricks

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

Multithreading

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

Manipulating Tasks

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

Manipulating Strings

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

Metaprogramming

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

Containers

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

Gathering Platform and Compiler Information

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

Working with the System

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

Scratching the Tip of the Iceberg

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

Customer Reviews

4.2 (5)

5 star

80%

4 star

0

3 star

0

2 star

0

1 star

20%

Using type vector of types

There are situations when it would be great to work with all the template parameters like they were in a container. Imagine that we are writing something, such as Boost.Variant:

#include <boost/mpl/aux_/na.hpp>

// boost::mpl::na == n.a. == not available
template <
    class T0 = boost::mpl::na,
    class T1 = boost::mpl::na,
    class T2 = boost::mpl::na,
    class T3 = boost::mpl::na,
    class T4 = boost::mpl::na,
    class T5 = boost::mpl::na,
    class T6 = boost::mpl::na,
    class T7 = boost::mpl::na,
    class T8 = boost::mpl::na,
    class T9 = boost::mpl::na
    >
struct variant;

The preceding code is the place where all the following interesting tasks start to happen:

How can we remove constant and volatile qualifiers from all the types?
How can we remove duplicate types?
How can we get the sizes of all the types?
How can we get the maximum...

Search

Your notes and bookmarks