Learning C++ Functional Programming

Wisnu Anggoro

• Publisher: Packt Publishing
• Year: 2017
• ISBN:
  9781787280588
• Edition: 1
• Topic: Computer Science
• Subtopic: Programming in C++
• Index: Computer Science

Apply Functional Programming techniques to C++ to build highly modular, testable, and reusable codeAbout This Book• Modularize your applications and make them highly reusable and testable• Get familiar with complex concepts such as metaprogramming, concurrency, and immutability• A highly practical guide to building functional code in C++ filled with lots of examples and real-world use casesWho This Book Is ForThis book is for C++ developers comfortable with OOP who are interested in learning how to apply the functional paradigm to create robust and testable apps.What You Will Learn• Get to know the difference between imperative and functional approaches• See the use of first-class functions and pure functions in a functional style• Discover various techniques to apply immutable state to avoid side effects• Design a recursive algorithm effectively• Create faster programs using lazy evaluation• Structure code using design patterns to make the design process easier• Use concurrency techniques to develop responsive software• Learn how to use the C++ Standard Template Library and metaprogramming in a functional way to improve code optimizationIn DetailFunctional 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.Style and approachThis book uses a module-based approach, where each module will cover important aspects of functional programming in C++ and will help you develop efficient and robust applications through gaining a practical understanding.

Diving into Modern C++

The C++ programming language has been changed dramatically since its invention in 1979. Some people in this era might be a little bit scared to code using C++ language since it is not user-friendly. The memory management we have to deal with sometimes makes people unwilling to use this language. Fortunately, since C++11--also known as modern C++, along with C++14 and C++17--has been released, numerous features have been introduced to simplify our code in the C++ language. Moreover, the best part of it is that the C++ programming language is a great language for any project, from low-level programming to web programming, as well as functional programming.

This chapter is the best place to start our journey in this book, as it is addressed to the C++ programmers to refresh their knowledge and will discuss the following topics:

• Understanding several new features in modern C++
• Implementing the C++ Standard Libraries in modern C++
• The use of the Lambda expression and all features included in C++ Lambda
• Using smart pointer to avoid manual memory management
• Dealing with many return values using tuples

Getting closer with several new features in modern C++

So, what is new in modern C++ in comparison to the old one? There are so many changes in modern C++ compared to the old one, and the book pages will dramatically increase if we discuss all of them. However, we will discuss the new features in modern C++, which we should know about, to make us more productive in coding activities. We will discuss several new keywords, such as auto, decltype, and nullptr. We will also discuss the enhancement of the begin() and end() function that has now become a non-member class function. We will also discuss the augmented support for the for-each technique to iterate over collections using the range-based for loop techniques.

The next few subsections in this chapter will also discuss the new features of modern C++, namely Lambda expressions, smart pointers, and tuples, which were just added in the C++11 release.

Defining the data type automatically using the auto keyword

Prior to the modern C++, the C++ language has a keyword named auto that is used to explicitly specify that the variable should have automatic duration. The automatic duration that adheres to the variable will create the variable at the point of definition (and initialized, if relevant) and destroy the variable when the block they are defined in is exited. For instance, the local variable will be created when it is defined at the beginning of the function and destroyed when the program exits the function where the local variable is there.

Since C++11, the auto keyword is used to tell the compiler to deduce the actual type of a variable that is being declared from its initializer. And since C++14, the keyword can also be applied to a function to specify the return type of the function that is a trailing return type. Now, in modern C++, the use of the auto keyword to specify the automatic duration is abolished since all variables are set to automatic duration by default.

The following is an auto.cpp code demonstrating the use of the auto keyword in the variables. We will define four variables with the auto keyword, and then find out the data type for each variable using the typeid() function. Let's take a look:

 /* auto.cpp */

 #include <iostream>
 #include <typeinfo>

 int main()
 {
 std::cout << "[auto.cpp]" << std::endl;

 // Creating several auto-type variables
 auto a = 1;
 auto b = 1.0;
 auto c = a + b;
 auto d = {b, c};

 // Displaying the preceding variables' type
 std::cout << "type of a: " << typeid(a).name() << std::endl;
 std::cout << "type of b: " << typeid(b).name() << std::endl;
 std::cout << "type of c: " << typeid(c).name() << std::endl;
 std::cout << "type of d: " << typeid(d).name() << std::endl;
 return 0;
 } 

As we can see in the preceding code, we have an a variable that will store the integer value and have a b variable that will store the double value. We calculate the addition of a and b and store the result in variable c. Here, we expect that c will store the double object since we add the integer and double object. The last is the d variable that will store the initializer_list<double> data type. When we run the preceding code, we will see the following output on the console:

As can be seen in the preceding snapshot, we are just given the first character of the data type, such as i for integer, d for double, and St16initializer_listIdE for initializer_list<double>, that is the last lowercase d character that stands for double.

We may have to enable the Run-Time Type Information (RTTI) feature in our compiler options to retrieve the data type object. However, GCC has enabled the feature by default. Also, the output of the use of the typeid() function depends on the compiler. We may get the raw type name or just a symbol as we did in the preceding example.

Besides, for variable, as we discussed earlier, the auto keyword can also be applied to a function to deduce a function's return type automatically. Suppose we have the following trivial function named add() to calculate the addition of two parameters:

 int add(int i, int j)
 {
 return i + j;
 } 

We can refactor the preceding method to use the auto keyword, as we can see in the following lines of code:

 auto add(int i, int j)
 {
 return i + j;
 } 

Similar to the auto-type variable, the compiler can decide the correct return type based on the returned value of the function. And, as shown in the preceding code, the function will indeed return the integer value since we just add two integer values.

Another feature that uses the auto keyword in modern C++ is trailing the return type syntax. By using this feature, we can specify the return type, the rest of the function prototype, or function signature. From the preceding code, we can refactor it to use the feature as follows:

 auto add(int i, int j) -> int
 {
 return i + j;
 } 

You might ask me why we have to specify the data type again after the arrow symbol (->), even though we have used the auto keyword. We will find the answer when we cover the decltype keyword in the next section. Also, by using this feature, we can now refactor the preceding auto.cpp code a little bit by modifying the syntax of the main() method, instead of the following syntax of main() function signature:

 int main()
 {
 // The body of the function
 } 

We can chan...

Table of contents

• Title Page
• Copyright
• Credits
• About the Author
• About the Reviewer
• www.PacktPub.com
• Customer Feedback
• Preface
• Diving into Modern C++
• Manipulating Functions in Functional Programming
• Applying Immutable State to the Function
• Repeating Method Invocation Using Recursive Algorithm
• Procrastinating the Execution Process Using Lazy Evaluation
• Optimizing Code with Metaprogramming
• Running Parallel Execution Using Concurrency
• Creating and Debugging Application in Functional Approach