万本电子书0元读

万本电子书0元读

顶部广告

C++ Reactive Programming电子书

售       价:¥

17人正在读 | 0人评论 6.2

作       者:Praseed Pai,Peter Abraham

出  版  社:Packt Publishing

出版时间:2018-06-29

字       数:45.7万

所属分类: 进口书 > 外文原版书 > 电脑/网络

温馨提示:数字商品不支持退换货,不提供源文件,不支持导出打印

为你推荐

  • 读书简介
  • 目录
  • 累计评论(0条)
  • 读书简介
  • 目录
  • 累计评论(0条)
Learn how to implement the reactive programming paradigm with C++ and build asynchronous and concurrent applications About This Book ? Efficiently exploit concurrency and parallelism in your programs ? Use the Functional Reactive programming model to structure programs ? Understand reactive GUI programming to make your own applications using Qt Who This Book Is For If you’re a C++ developer interested in using reactive programming to build asynchronous and concurrent applications, you’ll find this book extremely useful. This book doesn’t assume any previous knowledge of reactive programming. What You Will Learn ? Understand language-level concurrency in C++ ? Explore advanced C++ programming for the FRP ? Uncover the RxCpp library and its programming model ? Mix the FP and OOP constructs in C++ 17 to write well-structured programs ? Master reactive microservices in C++ ? Create custom operators for RxCpp ? Learn advanced stream processing and error handling In Detail Reactive programming is an effective way to build highly responsive applications with an easy-to-maintain code base. This book covers the essential functional reactive concepts that will help you build highly concurrent, event-driven, and asynchronous applications in a simpler and less error-prone way. C++ Reactive Programming begins with a discussion on how event processing was undertaken by different programming systems earlier. After a brisk introduction to modern C++ (C++17), you’ll be taken through language-level concurrency and the lock-free programming model to set the stage for our foray into the Functional Programming model. Following this, you’ll be introduced to RxCpp and its programming model. You’ll be able to gain deep insights into the RxCpp library, which facilitates reactive programming. You’ll learn how to deal with reactive programming using Qt/C++ (for the desktop) and C++ microservices for the Web. By the end of the book, you will be well versed with advanced reactive programming concepts in modern C++ (C++17). Style and approach The book includes real-world problems that you will solve with the reactive programming model. It highlights the way event processing has evolved in the programming world.
目录展开

Title Page

Copyright and Credits

C++ Reactive Programming

Packt Upsell

Why subscribe?

PacktPub.com

Contributors

About the authors

About the reviewer

Packt is searching for authors like you

Preface

Who this book is for

What this book covers

To get the most out of this book

Download the example code files

Download the color images

Conventions used

Get in touch

Reviews

Reactive Programming Model – Overview and History

Event-driven programming model

Event-driven programming on X Windows

Event-driven programming on Microsoft Windows

Event-driven programming under Qt

Event-driven programming under MFC

Other event-driven programming models

Limitations of classical event processing models

Reactive programming model

Functional reactive programming

The key interfaces of a reactive program

Pull-versus push-based reactive programming

The IEnumerable/IObservable duality

Converting events to IObservable<T>

The philosophy of our book

Summary

A Tour of Modern C++ and its Key Idioms

The key concerns of the C++ programming language

Zero cost abstraction

Expressivity

Substitutability

Enhancements to C++ for writing better code

Type deduction and inference

Uniform initialization of variables

Variadic templates

Rvalue references

Move semantics

Smart pointers

Lambda functions

Functors and Lambdas

Composition, currying, and partial function application

Function wrappers

Composing functions together with the pipe operator

Miscellaneous features

Fold expressions

Variant type

Other important topics

Range-based for loops and observables

Summary

Language-Level Concurrency and Parallelism in C++

What is concurrency?

Hello World of concurrency (using std::thread)

Managing threads

Thread launch

Thread join

Passing arguments into a thread

Using Lambdas

Ownership management

Sharing data between threads

Mutexes

Avoiding deadlock

Locking with std::unique_lock

Condition variables

A thread-safe stack data structure

Summary

Asynchronous and Lock-Free Programming in C++

Task-based parallelism in C++

Future and promise

std::packaged_task

std::async

C++ memory model

Memory access and concurrency

The modification contract

Atomic operations and types in C++

Atomic types

std::atomic_flag

std::atomic<bool>

Standard atomic integral types

std::atomic<T*> – pointer arithmetic

std::atomic<> primary class template

Memory ordering

Sequential consistency

Acquire-release ordering

Relaxed ordering

A lock-free data structure queue

Summary

Introduction to Observables

The GoF Observer pattern

The limitations of the GoF Observer pattern

A holistic look at GoF patterns

The OOP programming model and hierarchies

A Composite/Visitor pattern for expression processing

Flattening the composite for iterative processing

Map and filter operations on the list

Reversing the gaze for Observables!

Summary

Introduction to Event Stream Programming Using C++

What is Stream programming model?

Advantages of the Stream programming model

Applied Stream programming using the Streams library

Lazy evaluation

A simple Stream program

Aggregating values using the Stream paradigm

The STL and the Stream paradigm

A word about the Streams library

Event Stream programming

Advantages of Event Stream programming

The Streamulus library and its programming model

The Streamulus library – a peek into its internals

The Streamulus Library – a look into expression processing

The spreadsheet Library — a change-propagation engine

RaftLib – another Stream-processing library

What do these things have to do with Rx programming?

Summary

Introduction to Data Flow Computation and the RxCpp Library

The data flow computation paradigm

An introduction to the RxCpp library

The RxCpp library and its programming model

A simple Observable/Observer interaction

Filters and transformations with Observables

Streaming values from C++ containers

Creating Observables from scratch

Concatenating Observable Streams

Unsubscribing from Observable Streams

An introduction to marble diagrams for visual representation

RxCpp (Stream) operators

The average operator

The scan operator

Composing operators through the pipe operator

Working with Schedulers

A tale of two operators – flat versus concat map

More operators that are of importance

A peek into the things we haven't covered yet

Summary

RxCpp – the Key Elements

Observables

What's a producer?

Hot versus cold Observables

Hot Observables

Hot Observables and the replay mechanism

Observers and their variants (subscribers)

Subjects

Schedulers

ObserveOn versus SubscribeOn

The RunLoop Scheduler

Operators

Creational operators

Transformation operators

Filtering operators

Combining operators

Error-handling operators

Observable utility operators

Conditional and Boolean operators

Mathematical and aggregate operators

Connectable Observable operators

Summary

Reactive GUI Programming Using Qt/C++

A quick introduction to Qt GUI programming

Qt object model

Signals and slots

Event system

Event handlers

Sending events

Meta-object system

Hello World – Qt program

Qt event model with signals/slots/MOC – an example

Creating a custom widget

Creating the application dialog

Executing the application

Integrating the RxCpp library with the Qt event model

Qt event filter – a reactive approach

Creating the window – setting layouts and alignments

Event type specific observables

An introduction to RxQt

Summary

Design Patterns and Idioms for C++ Rx Programming

The OOP and design patterns movement

Key pattern catalogs

GOF patterns

POSA catalog

The design pattern redux

From design patterns to reactive programming

Flattening the hierarchy to navigate through them

From iterators to observables

The cell pattern

The active object pattern

Resource loan pattern

The event bus pattern

Summary

Reactive Microservices Using C++

The C++ language and web programming

The REST programming model

The C++ REST SDK

HTTP client programming using the C++ REST SDK

HTTP server programming using the C++ REST SDK

Testing the HTTP server using CURL and POSTMAN

The libcurl and the HTTP client programming

Kirk Shoop's CURL Wrapper library

The JSON and HTTP protocols

The C++ REST SDK-based REST server

Invoking REST services using the RxCurl library

A word about the Reactive microservices architecture

Fine-grained services

Polyglot persistence

Independent deployment

Service orchestration and choreography

Reactive web service call

Summary

Advanced Streams and Handling Errors

A short recap of the characteristics of a reactive system

RxCpp error and exception handling operators

Executing an action on an error

Resuming when an error occurs

Retry when an error occurs

Cleanup with the finally() operator

Schedulers and error handling

Event-based Stream handling – some examples

Aggregation based on Stream data

Application event handling example

Summary

Other Books You May Enjoy

Leave a review - let other readers know what you think

累计评论(0条) 0个书友正在讨论这本书 发表评论

发表评论

发表评论,分享你的想法吧!

买过这本书的人还买过

读了这本书的人还在读

回顶部