Explore the power of C++ templates, from function and class basics to advanced features like instantiation and concepts, enhancing code flexibility, reusability, and abstraction without performance loss.

cpp17.tar.gz

C++17

C++20

Templates are one of the many powerful features of Modern C++ programming. And with each new C++ standard, they become more important. 

Templates provide an efficient way to make your code more flexible and reusable, this way you can avoid repeating code that would otherwise be identical except for different types. Templates also give you the ability to provide abstraction without a performance penalty.

However, templates can be difficult to apply, can be counterintuitive, and have tricky error messages.

This course gives you the necessary information to overcome these hurdles and dive into the advanced topics. You’ll visit the basics such as function and class templates, and then explore the details to templates such as instantiation and fold expressions. Our journey also includes techniques based on templates, the design, and future directions of templates such as concepts. Based on this exhaustive tour of templates, a basic understanding of C++ is sufficient to master this course.

Let’s get started!

Generic Programming Templates in C++

# Expression Templates

Expression templates are "structures representing a computation at compile-time, which are evaluated only as needed to produce efficient code for the entire computation." 

Now we are at the center of lazy evaluation.

## Lazy Evaluation

The story about lazy evaluation in C++ is quite short. That will change in C++20, with the ranges library from **Eric Niebler**. Lazy evaluation is the default in Haskell. Lazy evaluation means that an expression is only evaluated when needed. 

This strategy has two benefits.

*    Lazy evaluation helps you to save time and memory.
*    You can define an algorithm on infinite data structures. Of course, you can only ask for a finite number of values at runtime.


**Advantages:**

- Creates a domain-specific language (DSL) 
- Avoidance of temporary data structures

**Disadvantages:**
- Longer compile-times
- Advanced programming technique (template metaprogramming)

What problem do expression templates solve? Thanks to expression templates, we can get rid of superfluous temporary objects in expressions. What do we mean by superfluous temporary objects? To demonstrate that, let's look at the implementation of the class `MyVector` below.

## A First Naive Approach

`MyVector` is a simple wrapper for an `std::vector<T>`. The wrapper class has two constructors (line 12 and 15), we have a `size` function which returns its size  (line 18 - 20), and the reading index operator (line 23 - 25) and writing index access (line 27 - 29).


Given below is the naive vector implementation:
   

In this lesson, we'll study expression templates in detail.

Introduction

Basics

Details

Techniques

Design

Future

Conclusion

Expression Templates

Expression Templates

Lazy Evaluation