Browse Library
Sign In Start Free Trial
Close icon Search icon
Account
Browse Library Advanced Search Sign In Start Free Trial

Add to playlist

Create a Playlist

Modal Close icon
You need to login to use this feature.
  • C++ Reactive Programming
  • Toc
  • feedback
C++ Reactive Programming

C++ Reactive Programming

By : Praseed Pai, Abraham
3 (8)
close
C++ Reactive Programming

C++ Reactive Programming

3 (8)
By: Praseed Pai, Abraham

Overview of this book

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).
Table of Contents (15 chapters)
close
close
Preface
Preface
Who this book is for
What this book covers
To get the most out of this book
Get in touch
Free Chapter
1
Reactive Programming Model – Overview and History
Reactive Programming Model – Overview and History
Event-driven programming model
Reactive programming model
Functional reactive programming
The key interfaces of a reactive program
Pull-versus push-based reactive programming
Converting events to IObservable<T>
The philosophy of our book
Summary
2
A Tour of Modern C++ and its Key Idioms
A Tour of Modern C++ and its Key Idioms
The key concerns of the C++ programming language
Enhancements to C++ for writing better code
Composing functions together with the pipe operator
Miscellaneous features
Range-based for loops and observables
Summary
3
Language-Level Concurrency and Parallelism in C++
Language-Level Concurrency and Parallelism in C++
What is concurrency?
Hello World of concurrency (using std::thread)
Managing threads
Using Lambdas
Sharing data between threads
A thread-safe stack data structure
Summary
4
Asynchronous and Lock-Free Programming in C++
Asynchronous and Lock-Free Programming in C++
Task-based parallelism in C++
C++ memory model
Memory access and concurrency
The modification contract
Atomic operations and types in C++
Atomic types
Memory ordering
A lock-free data structure  queue
Summary
5
Introduction to Observables
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
6
Introduction to Event Stream Programming Using C++
Introduction to Event Stream Programming Using C++
What is Stream programming model?
Applied Stream programming using the Streams library
Lazy evaluation
Event Stream programming
Summary
7
Introduction to Data Flow Computation and the RxCpp Library
Introduction to Data Flow Computation and the RxCpp Library
The data flow computation paradigm
An introduction to the RxCpp library
Creating Observables from the scratch
An introduction to marble diagrams for visual representation
RxCpp (Stream) Operators
A peek into the things we haven't covered yet
Summary
8
RxCpp – the Key Elements
RxCpp – the Key Elements
Observables
Observers and their variants (Subscribers)
Subjects
Schedulers
Operators
Summary
9
Reactive GUI Programming Using Qt/C++
Reactive GUI Programming Using Qt/C++
A quick introduction to Qt GUI programming
Hello World – Qt program
Qt event model with signals/slots/MOC – an example
Integrating the RxCpp library with the Qt event model
Summary
10
Creating Custom Operators in RxCpp
Creating Custom Operators in RxCpp
Philosophy of Rx operators
Chaining stock operators
Writing basic RxCpp custom operators
Different genres of custom operators
Writing custom operators that can be chained
Summary
11
Design Patterns and Idioms for C++ Rx Programming
chevron up
Design Patterns and Idioms for C++ Rx Programming
The OOP and Design patterns movement
Key Pattern catalogs
The Design pattern redux
From Design patterns to Reactive programming
The Cell pattern
The Active object pattern
The Resource Loan pattern
The Event bus pattern
Summary
12
Reactive Microservices Using C++
Reactive Microservices Using C++
The C++ language and web programming
The C++ REST SDK
Testing the HTTP server using CURL and POSTMAN
The JSON and HTTP protocol
The C++ REST SDK-based REST server
Invoking REST services using the RxCurl library
A word about the Reactive micro-services architecture
Summary
13
Advanced Streams and Handling Errors
Advanced Streams and Handling Errors
A short recap of the characteristics of a reactive system
RxCpp error and exception handling Operators
Schedulers and error handling
Event-based Stream handling – some examples
Summary
14
Other Books You May Enjoy
Other Books You May Enjoy
Leave a review - let other readers know what you think

The Event bus pattern

The Event bus acts as a intermediary between event sources and event sinks. An event source, or producer, emits the events to a bus, and classes that have subscribed to events (consumers) will get notified. The pattern could be an instance of the Mediator design pattern. In an Event bus implementation, we have the following archetypes

  • Producers: Classes which produce events
  • Consumers: Classes which consume events
  • Controllers: Classes which act as producers and consumers

In the implementation that follows, we have omitted the implementation of Controllers. The following code implements a toy version of an Event bus:

//----------- EventBus.cpp 
#include <rxcpp/rx.hpp> 
#include <memory> 
#include <map> 
#include <algorithm> 
using namespace std; 
//---------- Event Information 
struct EVENT_INFO{ 
   int id; 
   int err_code; 
   string description; 
   EVENT_INFO() { id = err_code = 0 ; description ="default";} 
   EVENT_INFO(int pid,int perr_code...
End of Section 7
Next Section
bookmark search playlist download
font-size

Change the font size

margin-width

Change margin width

day-mode

Change background colour

Close icon Search
Country selected
Close icon Your notes and bookmarks

Delete Bookmark

Modal Close icon
Are you sure you want to delete it?
Cancel
Yes, Delete