最新章節

• Summary
• Printing the object value
• Setting and deleting the breakpoint
• Continuing and stepping the debugging process
• Starting the debugging tool
• Debugging the code

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

• 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 更新時間：2021-07-02 20:51:57