最新章節(jié)
- Summary
- Printing the object value
- Setting and deleting the breakpoint
- Continuing and stepping the debugging process
- Starting the debugging tool
- Debugging the code
品牌：中圖公司
上架時(shí)間：2021-07-02 18:34:09
出版社：Packt Publishing
本書(shū)數(shù)字版權(quán)由中圖公司提供，并由其授權(quán)上海閱文信息技術(shù)有限公司制作發(fā)行
- Summary 更新時(shí)間：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 更新時(shí)間：2021-07-02 20:51:57
