Learning C++ Functional Programming

Name: Learning C++ Functional Programming | Apply Functional Programming Techniques to C++ to Build Highly Modular, Testable, and Reusable Code
Brand: Packt Publishing
Price: 45.59 EUR
Availability: OnlineOnly

Apply Functional Programming Techniques to C++ to Build Highly Modular, Testable, and Reusable Code

Wisnu Anggoro(Autor*in)

Packt Publishing

1. Auflage

Erschienen am 10. August 2017

304 Seiten

E-Book

ePUB mit Adobe-DRM

Systemvoraussetzungen

978-1-78728-058-8 (ISBN)

45,59 €inkl. 7% MwSt.

Systemvoraussetzungen

für ePUB mit Adobe-DRM

E-Book Einzellizenz

Als Download verfügbar

Beschreibung

Apply Functional Programming techniques to C++ to build highly modular, testable, and reusable codeAbout This BookModularize your applications and make them highly reusable and testableGet familiar with complex concepts such as metaprogramming, concurrency, and immutabilityA 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 LearnGet to know the difference between imperative and functional approachesSee the use of first-class functions and pure functions in a functional styleDiscover various techniques to apply immutable state to avoid side effectsDesign a recursive algorithm effectivelyCreate faster programs using lazy evaluationStructure code using design patterns to make the design process easierUse concurrency techniques to develop responsive softwareLearn 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.

Weitere Details

Inhalt

Cover
Copyright
Credits
About the Author
About the Reviewer
www.PacktPub.com
Customer Feedback
Table of Contents
Preface
Chapter 1: Diving into Modern C++
Getting closer with several new features in modern C++
Defining the data type automatically using the auto keyword
Querying the type of an expression using the decltype keyword
Pointing to a null pointer
Returning an iterator using non-member begin() and end() function
Iterating over collections using range-based for loops
Leveraging the use of C++ language with the C++ Standard Libraries
Placing any objects in the container
Using algorithms
Simplifying the function notation using a Lambda expression
Using the Lambda expression for a tiny function
Using the Lambda expression for multiline functions
Returning a value from the Lambda expression
Capturing a value to the Lambda expression
Preparing the value using initialization captures
Writing a generic Lambda expression to be used many times with many different data types
Avoiding manual memory management with smart pointers
Replacing a raw pointer using unique_ptr
Sharing objects using shared_ptr
Tracking the objects using a weak_ptr pointer
Storing many different data types using tuples
Unpacking tuples values
Returning a tuple value type
Summary
Chapter 2: Manipulating Functions in Functional Programming
Applying the first-class function in all functions
Passing a function as another function's parameter
Assigning a function to a variable
Storing a function in the container
Creating a new function from the existing functions at runtime
Getting acquainted with three functional techniques in the higher-order function
Executing each element list using map
Extracting data using filter
Combining all elements of a list using fold
Avoiding the side effect with pure function
Reducing a multiple arguments function with currying
Summary
Chapter 3: Applying Immutable State to the Function
Understanding the essential part from immutable object
Modifying a local variable
Modifying a variable passed into a function
Preventing the modification of a value
Applying the first-class function and the pure function to the immutable object
Developing the immutable object
Starting with a mutable object
Refactoring a mutable object into an immutable one
Enumerating the benefits of being immutable
Summary
Chapter 4: Repeating Method Invocation Using Recursive Algorithm
Repeating the function invocation recursively
Performing the iteration procedure to repeat the process
Performing the recursion procedure to repeat the process
Recurring the immutable function
Getting closer to tail recursion
Getting acquainted with functional, procedural, and backtracking recursion
Expecting results from functional recursion
Running a task recursively in procedural recursion
Backtracking recursion
Summary
Chapter 5: Procrastinating the Execution Process Using Lazy Evaluation
Evaluating the expression
Running the expression immediately with strict evaluation
Delaying the expression with non-strict evaluation
The basic concept of lazy evaluation
Delaying the process
Caching the value using the memoization technique
Optimizing the code using the memoization technique
Lazy evaluation in action
Designing Chunk and Row classes
Concatenating several rows
Iterating each Row class' element
Generating the infinite integer row
Generating an infinite prime numbers row
Refactoring eager evaluation to lazy evaluation
Summary
Chapter 6: Optimizing Code with Metaprogramming
Introduction to metaprogramming
Preprocessing the code using a macro
Dissecting template metaprogramming in the Standard Library
Building the template metaprogramming
Adding a value to the variable in the template
Mapping a function to the input parameters
Choosing the correct process based on the condition
Repeating the process recursively
Selecting a type in compile-time
Flow control with template metaprogramming
Deciding the next process by the current condition
Selecting the correct statement
Looping the process
Executing the code in compile-time
Getting a compile-time constant
Generating the class using a compile-time class generation
Benefits and drawbacks of metaprogramming
Summary
Chapter 7: Running Parallel Execution Using Concurrency
Concurrency in C++
Processing a single threading code
Processing a multithreading code
Synchronizing the threads using mutex
Avoiding synchronization issues
Unlocking the variable automatically
Avoiding deadlock using recursive mutex
Understanding the thread processing in a Windows operating system
Working with handle
Refactoring to a unique handle
Triggering an event
Calling an event from a thread
Summary
Chapter 8: Creating and Debugging Application in Functional Approach
Preparing an imperative class
Refactoring the imperative class to become a functional class
Passing a function as a parameter
Adding a base class
Transforming the class to become pure
Filtering the condition and implementing a Lambda expression
Implementing recursion and memoization techniques to the Customer class
Debugging the code
Starting the debugging tool
Continuing and stepping the debugging process
Setting and deleting the breakpoint
Printing the object value
Summary
Index

Systemvoraussetzungen

Als PDF speichern Als Link merken