Boost C++ Application Development Cookbook

Boost C++ Application Development Cookbook - Second Edition

By : Anton Polukhin Alekseevic

Buy this Book

Boost C++ Application Development Cookbook - Second Edition

By: Anton Polukhin Alekseevic

Buy this Book

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.

Title Page

Credits

About the Author

About the Reviewer

www.PacktPub.com

Customer Feedback

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

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

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

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

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

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

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

Manipulating heterogeneous containers in C++14

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

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

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

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

5 star

4 star

3 star

2 star

1 star

Comparing strings in an ultra-fast manner

It is a common task to manipulate strings. Here, we'll see how an operation of string comparison can be done quickly using some simple tricks. This recipe is a trampoline for the next one, where the techniques described here will be used to achieve constant time-complexity searches.

So, we need to make some class that is capable of quickly comparing strings for equality. We'll make a template function to measure the speed of comparison:

#include <string>

template <class T>
std::size_t test_default() {
    // Constants
    const std::size_t ii_max = 200000;
    const std::string s(
        "Long long long string that "
        "will be used in tests to compare "
        "speed of equality comparisons."
    );

    // Making some data, that will be 
    // used in comparisons.
    const T data1[] = {
        T(s),
        T(s + s),
        T(s + ". Whooohooo"),
        T(std::string(""))
    };

    const T data2[] = {
        T(s),
   ...

Boost C++ Application Development Cookbook - Second Edition

By : Anton Polukhin Alekseevic

Boost C++ Application Development Cookbook - Second Edition

By: Anton Polukhin Alekseevic

Overview of this book

Related Content you might be interested in

Current Title:

Boost C++ Application Development Cookbook - Second Edition

C++ High Performance

Modern C++ Programming Cookbook

The C++ Standard Library

Comparing strings in an ultra-fast manner