Boost C++ Application Development Cookbook

Boost C++ Application Development Cookbook

By : Antony Polukhin

Buy this Book

Boost C++ Application Development Cookbook

By: Antony Polukhin

Buy this Book

Overview of this book

Boost libraries are developed by professionals, tested on multiple platforms and processor architectures, and contain reliable solutions for a wide range of tasks. This Cookbook takes you on a journey of simplifying the process of application development and guides you through writing perfect applications fast. "Boost C++ Application Development Cookbook" provides you with a number of clear step-by-step recipes that will help you take advantage of the real power of Boost and C++, while giving you a good grounding in using it in any project. "Boost C++ Application Development Cookbook" looks at the Boost libraries, and breaks down the mystery and confusion about which library to use in which situation. It will take you through a number of clear, practical recipes that will help you to take advantage of the readily available solutions. Boost C++ Application Development Cookbook starts with teaching the basics of Boost libraries that are now mostly part of C++11 and leave no chance for memory leaks. Managing resources will become a piece of cake. We’ll see what kind of work can be done at compile time and what Boost containers can do. Do you think multithreading is a burden? Not with Boost. Think writing portable and fast servers is impossible? You’ll be surprised! Compilers and operating systems differ too much? Not with Boost. From manipulating images to graphs, directories, timers, files, strings – everyone will find an interesting topic. 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.

Boost C++ Application Development Cookbook

Credits

About the Author

About the Reviewers

www.PacktPub.com

Preface

Free Chapter

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

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

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

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

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

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

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

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

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

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

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

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

Customer Reviews

5 star

4 star

3 star

2 star

1 star

Using type "vector of types"

There are situations when it would be great to work with all the template parameters as if 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;

And the preceding code is 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 size of the input parameters?

All these tasks can be easily solved using Boost.MPL.

Getting ready

A basic knowledge...

Boost C++ Application Development Cookbook

By : Antony Polukhin

Boost C++ Application Development Cookbook

By: Antony Polukhin

Overview of this book

Related Content you might be interested in

Current Title:

Boost C++ Application Development Cookbook

Using type "vector of types"

Getting ready