Modern C++ Programming Cookbook

Modern C++ Programming Cookbook

By : Marius Bancila

Buy this Book

Modern C++ Programming Cookbook

By: Marius Bancila

Buy this Book

Overview of this book

C++ is one of the most widely used programming languages. Fast, efficient, and flexible, it is used to solve many problems. The latest versions of C++ have seen programmers change the way they code, giving up on the old-fashioned C-style programming and adopting modern C++ instead. Beginning with the modern language features, each recipe addresses a specific problem, with a discussion that explains the solution and offers insight into how it works. You will learn major concepts about the core programming language as well as common tasks faced while building a wide variety of software. You will learn about concepts such as concurrency, performance, meta-programming, lambda expressions, regular expressions, testing, and many more in the form of recipes. These recipes will ensure you can make your applications robust and fast. By the end of the book, you will understand the newer aspects of C++11/14/17 and will be able to overcome tasks that are time-consuming or would break your stride while developing.

Title Page

Credits

About the Author

About the Reviewer

www.PacktPub.com

Customer Feedback

Preface

Free Chapter

Learning Modern Core Language Features

Introduction

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

Working with Numbers and Strings

Introduction

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

Exploring Functions

Introduction

Defaulted and deleted functions

Using lambdas with standard algorithms

Using generic lambdas

Writing a recursive lambda

Writing a function template with a variable number of arguments

Using fold expressions to simplify variadic function templates

Implementing higher-order functions map and fold

Composing functions into a higher-order function

Uniformly invoking anything callable

Preprocessor and Compilation

Introduction

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

Introduction

Using vector as a default container

Using bitset for fixed-size sequences of bits

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

Finding elements in a range

Sorting a range

Initializing a range

Using set operations on a range

Using iterators to insert new elements in a container

Writing your own random access iterator

Container access with non-member functions

General Purpose Utilities

Introduction

Expressing time intervals with chrono::duration

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 a std::variant

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

Introduction

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

Introduction

Working with threads

Handling exceptions from thread functions

Synchronizing access to shared data with mutexes and locks

Avoiding using recursive mutexes

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

Robustness and Performance

Introduction

Using exceptions for error handling

Using noexcept for functions that do not throw

Ensuring constant correctness for a program

Creating compile-time constant expressions

Performing correct type casts

Using unique_ptr to uniquely own a memory resource

Using shared_ptr to share a memory resource

Implementing move semantics

Implementing Patterns and Idioms

Introduction

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

Introduction

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 text fixtures with Google Test

Controlling output with Google Test

Getting started with Catch

Writing and invoking tests with Catch

Asserting with Catch

Controlling output with Catch

Bibliography

Websites

Articles and books

Customer Reviews

5 star

4 star

3 star

2 star

1 star

Implementing a thread-safe singleton

Singleton is probably one of the most well-known design patterns. It restricts the instantiation of a single object of a class, something that is necessary in some cases, although many times the use of a singleton is rather an anti-pattern that can be avoided with other design choices. Since a singleton means a single instance of a class is available to an entire program, it is likely that such a unique instance might be accessible from different threads. Therefore, when you implement a singleton, you should also make it thread-safe. Before C++11, doing that was not an easy job, and a double-checked locking technique was the typical approach. However, Scott Meyers and Andrei Alexandrescu showed, in a paper called C++ and the Perils of Double-Checked Locking, that using this pattern did not guarantee a thread-safe singleton implementation in portable C++. Fortunately, this changed in C++11, and this recipe shows how to write one in modern C++.

Modern C++ Programming Cookbook

By : Marius Bancila

Modern C++ Programming Cookbook

By: Marius Bancila

Overview of this book

Related Content you might be interested in

Current Title:

Modern C++ Programming Cookbook

Template Metaprogramming with C++

The Modern C++ Challenge

The C++ Standard Library

Implementing a thread-safe singleton

Getting ready...