As far as developers are concerned, the three key concerns that C++ programming language designers keep in mind were (and still are) as follows:

• Zero Cost Abstraction - No performance penalty for higher level abstraction
• Expressivity - A user defined type (UDT) or class should be as expressive as built-in types
• Substitutability - A UDT can be substituted wherever built-in-types are expected (as in generic data structures and algorithms)

We will discuss these briefly.

The C++ programming language has always helped developers to write code that exploits the microprocessor (on which generated code runs) and also raise the level of abstraction when it matters...

The programming language universe has changed a lot in the last decade and those changes should reflect in the  C++ programming language in its new avatar. Most of the innovations in Modern C++ involve handling advanced abstractions and the introduction of functional programming constructs to support language level concurrency. Most modern languages have got a garbage collector and a run-time manages these complexities. The C++ programming language does not have automatic garbage collection as part of the language standard. The C++ programming languages with its implicit guarantee of Zero cost abstraction (you do not pay for what you do not use) and maximum run-time performance, has to resort to a lot of compile-time tricks and meta programming techniques to achieve the abstraction level supported by a language such as C#, Java...

The Unix operating system's command line shell allows the standard output of one function to be piped into the another to form a filter chain. Later, this feature became part of every command line shell offered as part of most operating systems. While writing functional style code, when we combine methods through functional composition, the code becomes hard to read because of deep nesting. Now, with Modern C++ we can overload the pipe (|) operator to allow chaining several functions together, like we do commands in a Unix shell or Windows PowerShell console. That is why someone re-christened the LISP language as Lots of Irritating and Silly Parentheses. The RxCpp library uses the | operator extensively to compose functions together. The following code helps us understand how one can create pipeable functions. We will...

So far, we have covered the most important semantic changes to the language beginning with the C++ 11 standard. The purpose of this chapter is to highlight key changes that might be useful in writing idiomatic Modern C++ programs. The C++ 17 standard added some more stuff into the language. We will be highlighting a few more features of the language to wrap up this discussion.

The C++ 17 standard added support for fold expressions to ease the generation of variadic functions. The Compiler does pattern matching and generates the code by inferring the intent of the programmer. The following code snippet demonstrates the idea:

//---------------- Folds.cpp
//--------------- Requires...

In this section, we will implement range-based for loops on a custom type written by us to help you understand how all the things mentioned earlier in this chapter can be put together to write programs that support modern idioms. We will  implement a class that returns a series of numbers within a bound and will implement infrastructure support for the iteration of the values based on range-based for loops. First, we write the  "Iterable/Iterator" (aka "Enumerable/Enumerable") version by leveraging the range-based for loops.  After some tweaks, the implementation will be transformed to Observable/Observer (the key interface of Reactive Programming) patterns: The implementation of Observable/Observer pattern here is just for elucidation purpose and  should not be considered as an Industrial strength implementation...

In this chapter, we learned about programming language features that a C++ programmer should be comfortable with while writing Reactive programs, or for that matter any kind of programs. We talked about type inference, Variadic templates, rvalue references and move semantics, Lambda functions, elementary Functional programming, pipeable operators, and implementation of Iterators and observers. In the next chapter, we will  learn about concurrent programming support provided by the C++ programming language.