Book Image

Advanced C++ Programming Cookbook

By : Dr. Rian Quinn

Book Image

Advanced C++ Programming Cookbook

By: Dr. Rian Quinn

Overview of this book

If you think you've mastered C++ and know everything it takes to write robust applications, you'll be in for a surprise. With this book, you'll gain comprehensive insights into C++, covering exclusive tips and interesting techniques to enhance your app development process. You'll kick off with the basic principles of library design and development, which will help you understand how to write reusable and maintainable code. You'll then discover the importance of exception safety, and how you can avoid unexpected errors or bugs in your code. The book will take you through the modern elements of C++, such as move semantics, type deductions, and coroutines. As you advance, you'll delve into template programming - the standard tool for most library developers looking to achieve high code reusability. You'll explore the STL and learn how to avoid common pitfalls while implementing templates. Later, you'll learn about the problems of multithreaded programming such as data races, deadlocks, and thread starvation. You'll also learn high-performance programming by using benchmarking tools and libraries. Finally, you'll discover advanced techniques for debugging and testing to ensure code reliability. By the end of this book, you'll have become an expert at C++ programming and will have gained the skills to solve complex development problems with ease.

Preface

Who this book is for

What this book covers

To get the most out of this book

Getting Started with Library Development

Getting Started with Library Development

Technical requirements

Understanding the principle of least surprise

How to namespace everything

Header-only libraries

Learning library development best practices

Learning how to use the boost APIs

Free Chapter

Using Exceptions for Error Handling

Using Exceptions for Error Handling

Technical requirements

Using the noexcept specifier

Using the noexcept operator

Learning why to never throw exceptions in destructors

Easily creating your own exception classes

Implementing Move Semantics

Implementing Move Semantics

Technical requirements

Using compiler-generated special class member functions and the Big Five

Making your class movable

Move-only types

Implementing the noexcept move constructor

Learning to be wary of const&&

Referencing qualified member functions

Exploring objects that cannot be moved or copied

Using Templates for Generic Programming

Using Templates for Generic Programming

Technical requirements

Implementing SFINAE

Learning perfect forwarding

Using if constexpr

Using tuples to work with parameter packs

Using type traits to overload functions and objects

Learning how to implement template<auto>

Working with explicit template declarations

Concurrency and Synchronization

Concurrency and Synchronization

Technical requirements

Working with mutexes

Using atomic data types

Understanding what const & mutable mean in the context of multiple threads

Making a class thread-safe

Synchronization wrappers and how to implement them

Blocking operations versus asynchronous programming

Working with promises and futures

Optimizing Your Code for Performance

Optimizing Your Code for Performance

Technical requirements

Benchmarking your code

Looking at assembly code

Reducing the number of memory allocations

Declaring noexcept

Debugging and Testing

Debugging and Testing

Technical requirements

Getting to grips with unit testing

Working with ASAN, the address sanitizer

Working with UBSAN, the undefined behavior sanitizer

Using #ifndef NDEBUG to conditionally execute additional checks

Creating and Implementing Your Own Container

Creating and Implementing Your Own Container

Technical requirements

Using a simple wrapper around std::vector

Adding the relevant parts of the std::set API

Working with iterators

Adding the relevant parts of the std::vector API

Exploring Type Erasure

Exploring Type Erasure

Technical requirements

How to erase a type with inheritance

Using C++ templates to write generic functions

Learning the C++ type eraser pattern

Implementing delegates with type erasing

An In-Depth Look at Dynamic Allocation

An In-Depth Look at Dynamic Allocation

Technical requirements

Comparing std::shared_ptr and std::unique_ptr

Converting from a std::unique_ptr into a std::shared_ptr

Working with circular references

Typecasting with smart pointers

The heap under a microscope

Common Patterns in C++

Common Patterns in C++

Technical requirements

Learning the factory pattern

Using the singleton pattern properly

Extending your objects with the decorator pattern

Adding communication with the observer pattern

Improving performance with static polymorphism

A Closer Look at Type Deduction

A Closer Look at Type Deduction

Technical requirements

Using auto and type deduction

Learning how decltype type deduction rules work

Working with template function type deduction

Leveraging template class type deduction in C++17

Working with user-defined type deduction in C++17

Bonus - Using C++20 Features

Bonus - Using C++20 Features

Technical requirements

Looking at Concepts in C++20

Working with Modules in C++20

Introducing std::span, a new view on arrays

Working with Ranges in C++20

Learning how to use Coroutines in C++20

Other Books You May Enjoy

Other Books You May Enjoy

Leave a review - let other readers know what you think

Customer Reviews

5 star

0

4 star

0

3 star

0

2 star

0

1 star

0

Implementing Move Semantics

In this chapter, we will learn some advanced C++ move semantics. We will first discuss the Big Five, which is an idiom that simply encourages programmers to explicitly define the destruction and move/copy semantics of a class. Next, we will learn how to define a move constructor and move assignment operator; the different combinations of move semantics (including move-only and non-copyable); non-movable classes; and how to implement these classes and why they are important.

This chapter will also discuss some common pitfalls such as why a const && move makes no sense, and how to overcome l-value versus r-value reference types. The recipes in this chapter are important because once you enable C++11 or higher, move semantics is enabled, which changes how C++ fundamentally handles classes in numerous situations. The recipes in this chapter provide...