Modern C++ Programming Cookbook - Second Edition

By : Marius Bancila

5 (1)

Buy this Book

Modern C++ Programming Cookbook - Second Edition

5 (1)

By: Marius Bancila

Buy this Book

Overview of this book

C++ has come a long way to be one of the most widely used general-purpose languages that is fast, efficient, and high-performance at its core. The updated second edition of Modern C++ Programming Cookbook addresses the latest features of C++20, such as modules, concepts, coroutines, and the many additions to the standard library, including ranges and text formatting. The book is organized in the form of practical recipes covering a wide range of problems faced by modern developers. The book also delves into the details of all the core concepts in 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. It goes into the performance aspects of programming in depth, teaching developers how to write fast and lean code with the help of best practices. Furthermore, the book explores useful patterns and delves into the implementation of many idioms, including pimpl, named parameter, and attorney-client, teaching techniques such as avoiding repetition with the factory pattern. There is also a chapter dedicated to unit testing, where you are introduced to three of the most widely used libraries for C++: Boost.Test, Google Test, and Catch2. By the end of the book, you will be able to effectively leverage the features and techniques of C++11/14/17/20 programming to enhance the performance, scalability, and efficiency of your applications.

Preface

Who this book is for

What this book covers

To get the most out of this book

Get in touch

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

Free Chapter

Working with Numbers and Strings

Converting between numeric and string types

Limits and other properties of numeric types

Generating pseudo-random numbers

Initializing all bits of internal state of 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 string_view instead of constant string references

Formatting text with std::format

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

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

Using std::variant as a type-safe union

Visiting an std::variant

Using std::span for contiguous 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

Working with Files and Streams

Reading and writing raw data from/to binary files

Reading and writing objects from/to binary files

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

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

Using thread synchronization mechanisms

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

Performing correct type casts

Using unique_ptr to uniquely own a memory resource

Using shared_ptr to share a memory resource

Implementing move semantics

Consistent comparison with the operator <=>

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

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 outputs 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 Plus Plus 20 Core Features

Working with modules

Understanding module partitions

Specifying requirements on template arguments with concepts

Using requires expressions and clauses

Iterating over collections with the ranges library

Creating your own range view

Creating a coroutine task type for asynchronous computations

Creating a coroutine generator type for sequences of values

Bibliography

Websites

Articles and books

Other Books You May Enjoy

Index

Customer Reviews

5 (1)

5 star

100%

4 star

3 star

2 star

1 star

Creating a coroutine task type for asynchronous computations

A major component of the C++20 standard is represented by coroutines. Simply put, coroutines are functions that can be suspended and resumed. Coroutines are an alternative to writing asynchronous code. They help simplify asynchronous I/O code, lazy computations, or event-driven applications. When a coroutine is suspended, the execution returns to the caller and the data necessary to resume the coroutine is stored separately from the stack. For this reason, the C++20 coroutines are called stackless. Unfortunately, the C++20 standard does not define actual coroutines types, but only a framework for building them. This makes writing asynchronous code with coroutines difficult without relying on third-party components.

In this recipe, you will learn how to write a coroutine task type that represents an asynchronous computation that starts executing when the task is awaited.

Getting ready

The several standard...

Modern C++ Programming Cookbook - Second Edition

By : Marius Bancila

Modern C++ Programming Cookbook - Second Edition

By: Marius Bancila

Overview of this book

Related Content you might be interested in

Current Title:

Modern C++ Programming Cookbook - Second Edition

Template Metaprogramming with C++

The Modern C++ Challenge

The C++ Standard Library

Creating a coroutine task type for asynchronous computations

Getting ready