Name: Learning C++ Functional Programming
Author: Wisnu Anggoro
ISBN: 9781787280588

微信读书书城Learning C++ Functional Programming

首页我的书架登录

翻译完成

切换

Learning C++ Functional Programming

Wisnu Anggoro

扉页
cover
+书签
Title Page
Copyright
Learning C++ Functional Programming
Credits
About the Author
About the Reviewer
www.PacktPub.com
Why subscribe?
Customer Feedback
Preface
What this book covers
What you need for this book
Who this book is for
Conventions
Reader feedback
Customer support
Downloading the example code
Downloading the color images of this book
Errata
Piracy
Questions
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
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
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
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
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
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
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
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

简介

版权

Learning C++ Functional Programming