Modern C++ Programming Cookbook - Third Edition

By : Marius Bancila

Modern C++ Programming Cookbook - Third Edition

By: Marius Bancila

Overview of this book

The updated third edition of Modern C++ Programming Cookbook addresses the latest features of C++23, such as the stack library, the expected and mdspan types, span buffers, formatting library improvements, and updates to the ranges library. It also gets into more C++20 topics not previously covered, such as sync output streams and source_location. The book is organized in the form of practical recipes covering a wide range of real-world problems. It gets into the details of all the core concepts of modern C++ programming, such as functions and classes, iterators and algorithms, streams and the file system, threading and concurrency, smart pointers and move semantics, and many others. You will cover the performance aspects of programming in depth, and learning to write fast and lean code with the help of best practices. You will explore useful patterns and the implementation of many idioms, including pimpl, named parameter, attorney-client, and the factory pattern. A chapter dedicated to unit testing introduces you to three of the most widely used libraries for C++: Boost.Test, Google Test, and Catch2. By the end of this modern C++ programming book, you will be able to effectively leverage the features and techniques of C++11/14/17/20/23 programming to enhance the performance, scalability, and efficiency of your applications.

Preface

Who this book is for

What this book covers

What’s new in this edition

To get the most out of this book

Get in touch

Free Chapter

Learning Modern Core Language Features

Using auto whenever possible

Creating type aliases and alias templates

Understanding uniform initialization

Understanding the various forms of non-static member initialization

Controlling and querying object alignment

Using scoped enumerations

Using override and final for virtual methods

Using range-based for loops to iterate on a range

Enabling range-based for loops for custom types

Using explicit constructors and conversion operators to avoid implicit conversion

Using unnamed namespaces instead of static globals

Using inline namespaces for symbol versioning

Using structured bindings to handle multi-return values

Simplifying code with class template argument deduction

Using the subscript operator to access elements in a collection

Working with Numbers and Strings

Understanding the various numeric types

Limits and other properties of numeric types

Converting between numeric and string types

Understanding the various character and string types

Printing Unicode characters to the output console

Generating pseudo-random numbers

Properly initializing a pseudo-random number generator

Creating cooked user-defined literals

Creating raw user-defined literals

Using raw string literals to avoid escaping characters

Creating a library of string helpers

Verifying the format of a string using regular expressions

Parsing the content of a string using regular expressions

Replacing the content of a string using regular expressions

Using std::string_view instead of constant string references

Formatting and printing text with std::format and std::print

Using std::format with user-defined types

Exploring Functions

Defaulted and deleted functions

Using lambdas with standard algorithms

Using generic and template lambdas

Writing a recursive lambda

Writing function templates

Writing a function template with a variable number of arguments

Using fold expressions to simplify variadic function templates

Implementing the higher-order functions map and fold

Composing functions into a higher-order function

Uniformly invoking anything callable

Preprocessing and Compilation

Conditionally compiling your source code

Using the indirection pattern for preprocessor stringification and concatenation

Performing compile-time assertion checks with static_assert

Conditionally compiling classes and functions with enable_if

Selecting branches at compile time with constexpr if

Providing metadata to the compiler with attributes

Standard Library Containers, Algorithms, and Iterators

Using vector as a default container

Using bitset for fixed-size sequences of bits

Using vector<bool> for variable-size sequences of bits

Using the bit manipulation utilities

Finding elements in a range

Sorting a range

Initializing a range

Using set operations on a range

Using iterators to insert new elements into a container

Writing your own random-access iterator

Container access with non-member functions

Selecting the right standard containers

General-Purpose Utilities

Expressing time intervals with chrono::duration

Working with calendars

Converting times between time zones

Measuring function execution time with a standard clock

Generating hash values for custom types

Using std::any to store any value

Using std::optional to store optional values

Chaining together computations that may or may not produce a value

Using std::variant as a type-safe union

Visiting a std::variant

Using std::expected to return a value or an error

Using std::span for contiguous sequences of objects

Using std::mdspan for multi-dimensional views of sequences of objects

Registering a function to be called when a program exits normally

Using type traits to query properties of types

Writing your own type traits

Using std::conditional to choose between types

Providing logging details with source_location

Using the stacktrace library to print the call sequence

Working with Files and Streams

Reading and writing raw data from/to binary files

Reading and writing objects from/to binary files

Using streams on fixed-size external buffers

Using localized settings for streams

Using I/O manipulators to control the output of a stream

Using monetary I/O manipulators

Using time I/O manipulators

Working with filesystem paths

Creating, copying, and deleting files and directories

Removing content from a file

Checking the properties of an existing file or directory

Enumerating the content of a directory

Finding a file

Leveraging Threading and Concurrency

Working with threads

Synchronizing access to shared data with mutexes and locks

Finding alternatives for recursive mutexes

Handling exceptions from thread functions

Sending notifications between threads

Using promises and futures to return values from threads

Executing functions asynchronously

Using atomic types

Implementing parallel map and fold with threads

Implementing parallel map and fold with tasks

Implementing parallel map and fold with standard parallel algorithms

Using joinable threads and cancellation mechanisms

Synchronizing threads with latches, barriers, and semaphores

Synchronizing writing to output streams from multiple threads

Robustness and Performance

Using exceptions for error handling

Using noexcept for functions that do not throw exceptions

Ensuring constant correctness for a program

Creating compile-time constant expressions

Creating immediate functions

Optimizing code in constant-evaluated contexts

Using virtual function calls in constant expressions

Performing correct type casts

Implementing move semantics

Using unique_ptr to uniquely own a memory resource

Using shared_ptr to share a memory resource

Consistent comparison with the operator <=>

Comparing signed and unsigned integers safely

Implementing Patterns and Idioms

Avoiding repetitive if-else statements in factory patterns

Implementing the pimpl idiom

Implementing the named parameter idiom

Separating interfaces and implementations with the non-virtual interface idiom

Handling friendship with the attorney-client idiom

Static polymorphism with the curiously recurring template pattern

Adding functionality to classes with mixins

Implementing a thread-safe singleton

Exploring Testing Frameworks

Getting started with Boost.Test

Writing and invoking tests with Boost.Test

Asserting with Boost.Test

Using fixtures in Boost.Test

Controlling output with Boost.Test

Getting started with Google Test

Writing and invoking tests with Google Test

Asserting with Google Test

Using test fixtures with Google Test

Controlling output with Google Test

Getting started with Catch2

Writing and invoking tests with Catch2

Asserting with Catch2

Controlling output with Catch2

C++ 20 Core Features

Working with modules

Understanding module partitions

Specifying requirements on template arguments with concepts

Using requires expressions and clauses

Exploring abbreviated function templates

Iterating over collections with the ranges library

Exploring the standard range adaptors

Converting a range to a container

Creating your own range view

Using constrained algorithms

Creating a coroutine task type for asynchronous computations

Creating a coroutine generator type for sequences of values

Generating a sequence of values with the std::generator type

Other Books You May Enjoy

Index

Customer Reviews

5 star

4 star

3 star

2 star

1 star

Synchronizing threads with latches, barriers, and semaphores

The thread support library from C++11 includes mutexes and condition variables that enable thread-synchronization to shared resources. A mutex allows only one thread of multiple processes to execute, while other threads that want to access a shared resource are put to sleep. Mutexes can be expensive to use in some scenarios. For this reason, the C++20 standard features several new, simpler synchronization mechanisms: latches, barriers, and semaphores. Although these do not provide new use cases, they are simpler to use and can be more performant because they may internally rely on lock-free mechanisms.

Getting ready

The new C++20 synchronization mechanisms are defined in new headers. You have to include <latch> for std::latch, <barrier>, or std::barrier, and <semaphore> for std::counting_semaphore and std::binary_semaphore.

The code snippets in this recipe will use the following two functions...

Modern C++ Programming Cookbook - Third Edition

By : Marius Bancila

Modern C++ Programming Cookbook - Third Edition

By: Marius Bancila

Overview of this book

Related Content you might be interested in

Current Title:

Modern C++ Programming Cookbook - Third Edition

Template Metaprogramming with C++

The Modern C++ Challenge

The C++ Standard Library

Synchronizing threads with latches, barriers, and semaphores

Getting ready