Running Parallel Execution Using Concurrency | Learning C++ Functional Programming

Sign In Start Free Trial

Book Overview & Buying
Table Of Contents

Learning C++ Functional Programming

By : Wisnu Anggoro

3 (5)

Learning C++ Functional Programming

3 (5)

By: Wisnu Anggoro

Overview of this book

Functional programming allows developers to divide programs into smaller, reusable components that ease the creation, testing, and maintenance of software as a whole. Combined with the power of C++, you can develop robust and scalable applications that fulfill modern day software requirements. This book will help you discover all the C++ 17 features that can be applied to build software in a functional way. The book is divided into three modules—the first introduces the fundamentals of functional programming and how it is supported by modern C++. The second module explains how to efficiently implement C++ features such as pure functions and immutable states to build robust applications. The last module describes how to achieve concurrency and apply design patterns to enhance your application’s performance. Here, you will also learn to optimize code using metaprogramming in a functional way. By the end of the book, you will be familiar with the functional approach of programming and will be able to use these techniques on a daily basis.

Preface

Preface

What this book covers

What you need for this book

Who this book is for

Conventions

Reader feedback

Customer support

Free Chapter

Diving into Modern C++

Diving into Modern C++

Getting closer with several new features in modern C++

Leveraging the use of C++ language with the C++ Standard Libraries

Simplifying the function notation using a Lambda expression

Avoiding manual memory management with smart pointers

Storing many different data types using tuples

Summary

Manipulating Functions in Functional Programming

Manipulating Functions in Functional Programming

Applying the first-class function in all functions

Getting acquainted with three functional techniques in the higher-order function

Avoiding the side effect with pure function

Reducing a multiple arguments function with currying

Summary

Applying Immutable State to the Function

Applying Immutable State to the Function

Understanding the essential part from immutable object

Preventing the modification of a value

Applying the first-class function and the pure function to the immutable object

Developing the immutable object

Enumerating the benefits of being immutable

Summary

Repeating Method Invocation Using Recursive Algorithm

Repeating Method Invocation Using Recursive Algorithm

Repeating the function invocation recursively

Recurring the immutable function

Getting closer to tail recursion

Getting acquainted with functional, procedural, and backtracking recursion

Summary

Procrastinating the Execution Process Using Lazy Evaluation

Procrastinating the Execution Process Using Lazy Evaluation

Evaluating the expression

The basic concept of lazy evaluation

Lazy evaluation in action

Summary

Optimizing Code with Metaprogramming

Optimizing Code with Metaprogramming

Introduction to metaprogramming

Building the template metaprogramming

Selecting a type in compile-time

Flow control with template metaprogramming

Executing the code in compile-time

Benefits and drawbacks of metaprogramming

Summary

Running Parallel Execution Using Concurrency

Running Parallel Execution Using Concurrency

Concurrency in C++

Synchronizing the threads using mutex

Understanding the thread processing in a Windows operating system

Summary

Creating and Debugging Application in Functional Approach

Creating and Debugging Application in Functional Approach

Preparing an imperative class

Refactoring the imperative class to become a functional class

Debugging the code

Summary

Synchronizing the threads using mutex

As of now, we have successfully executed a multithreading code. However, a problem will occur if we consume a shared object and manipulate it inside the thread. It is called synchronization. In this section, we will try to avoid this problem by applying a mutex technique.

Avoiding synchronization issues

As we discussed earlier, in this section, we have to ensure that the shared object we run in the thread gives the correct value when it is executing. Let's suppose we have a global variable named counter and we plan to increase its value in all the five threads we have. Each thread will execute 10000 times increment iteration, so we expect to get 50000 as a result for all five threads. The code is as follows:

    /* notsync.cpp */
    #include <thread>
    #include <iostream>

    using namespace std;

    auto main() -> int
    {
      cout << "[notsync.cpp]" << endl;

      int counter = 0;

      thread threads[5];

      for...

CONTINUE READING

83

Tech Concepts

36

Programming languages

73

Tech Tools

Unlimited access to the largest independent learning library in tech of over 8,000 expert-authored tech books and videos.

Innovative learning tools, including AI book assistants, code context explainers, and text-to-speech.

50+ new titles added per month and exclusive early access to books as they are being written.

Learning C++ Functional Programming

Search

Your notes and bookmarks